From 894b48758e36d5cefc29f1a997c30e60d1e40726 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Fri, 17 Jul 2026 16:45:22 -0600
Subject: [PATCH 01/25] Add Guides section

---
 _data/display_as.yml                          |  3 ++
 _data/display_as_py_r_js.yml                  |  3 ++
 _includes/layouts/side-bar.html               |  3 ++
 _includes/posts/documentation_eg.html         | 26 ++++++++++++++
 .../posts/mainlang_documentation_eg.html      | 35 +++++++++++++++++++
 .../2026-07-17-plotly_js-guides-index.html    | 25 +++++++++++++
 6 files changed, 95 insertions(+)
 create mode 100644 _posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html

diff --git a/_data/display_as.yml b/_data/display_as.yml
index 74d89ff02..4a557b5ca 100644
--- a/_data/display_as.yml
+++ b/_data/display_as.yml
@@ -13,6 +13,9 @@ signal-analysis:
 file_settings:
     reference: '#fundamentals'
     text: Fundamentals
+guide:
+    reference: '#guides'
+    text: Guides
 basic:
     reference: '#basic-charts'
     text: Basic
diff --git a/_data/display_as_py_r_js.yml b/_data/display_as_py_r_js.yml
index d01a415a9..f9fae4381 100644
--- a/_data/display_as_py_r_js.yml
+++ b/_data/display_as_py_r_js.yml
@@ -13,6 +13,9 @@ signal-analysis:
 file_settings:
     reference: 'plotly-fundamentals'
     text: Fundamentals
+guide:
+    reference: 'guides'
+    text: Guides
 basic:
     reference: 'basic-charts'
     text: Basic Charts
diff --git a/_includes/layouts/side-bar.html b/_includes/layouts/side-bar.html
index 2270db9c3..5d4a74dcf 100644
--- a/_includes/layouts/side-bar.html
+++ b/_includes/layouts/side-bar.html
@@ -157,6 +157,9 @@
                         <a href="/javascript/configuration-options/" class="js-splash--navigation-item">Configuration
                             Options</a>
                     </li>
+                    <li class="--sidebar-item">
+                        <a href="/javascript/guides/" class="js-splash--navigation-item">Guides</a>
+                    </li>
                     {% endif %}
 
                     <!-- R Specific -->
diff --git a/_includes/posts/documentation_eg.html b/_includes/posts/documentation_eg.html
index 7a831ae1e..9585d9887 100644
--- a/_includes/posts/documentation_eg.html
+++ b/_includes/posts/documentation_eg.html
@@ -8,6 +8,8 @@
 {%- for page in languagelist -%}
 {% if page.display_as == "file_settings" %}
 {% assign file_settings = true %}
+{% elsif page.display_as == "guide" %}
+{% assign guide = true %}
 {% elsif page.display_as == "chart_type" or page.display_as == "basic" %}
 {% assign chart_type = true %}
 {% elsif page.display_as == "statistical" %}
@@ -115,6 +117,30 @@
 </section>
 {% endif %}
 
+{% if guide %}
+<section class="--tutorial-section">
+    <header class="--section-header">
+
+        {% if show_header %}
+        <a href="#guides" name="guides" id="guides">Guides</a>
+        {% endif %}
+
+    </header>
+    <section class="--grid">
+        <ul class="--grid-list">
+            {%- for page in languagelist -%}
+            {% if page.display_as == "guide" %}
+
+            {% include layouts/grid-item.html %}
+
+
+            {% endif %}
+            {%- endfor -%}
+        </ul>
+    </section>
+</section>
+{% endif %}
+
 {% if ai_ml %}
 <section class="--tutorial-section" id="ai_ml">
     <header class="--section-header">
diff --git a/_includes/posts/mainlang_documentation_eg.html b/_includes/posts/mainlang_documentation_eg.html
index 0443c98b7..42ad305e3 100644
--- a/_includes/posts/mainlang_documentation_eg.html
+++ b/_includes/posts/mainlang_documentation_eg.html
@@ -11,6 +11,8 @@
     {% if page.layout != "langindex" %}
         {% if page.display_as == "file_settings" %}
             {% assign file_settings = true %}
+        {% elsif page.display_as == "guide" %}
+            {% assign guide = true %}
         {% elsif page.display_as == "chart_type" or page.display_as == "basic" %}
             {% assign chart_type = true %}
         {% elsif page.display_as == "statistical" %}
@@ -88,6 +90,39 @@
 </section>
 {% endif %}
 
+{% if guide %}
+<section class="--tutorial-section">
+    <header class="--section-header">
+        <a href="#guides" name="guides" id="guides">Guides</a>
+
+        {% assign forloop_idx = 0 %}
+        {%- for page in languagelist -%}
+            {% if page.display_as == "guide" and page.layout != "langindex" %}
+                {% assign forloop_idx = forloop_idx | plus:1 %}
+            {% endif %}
+        {%- endfor -%}
+
+        {% if forloop_idx >= num_examples %}
+        <a href="/{{language}}/guides" class="langindexlink">More Guides &raquo;</a>
+        {% endif %}
+    </header>
+    <section class="--grid">
+        <ul class="--grid-list">
+
+            {% assign forloop_idx = 0 %}
+
+            {%- for page in languagelist -%}
+                {% if page.display_as == "guide" and page.layout != "langindex" and forloop_idx < num_examples  %}
+                    {% assign forloop_idx = forloop_idx | plus:1 %}
+                    {% include layouts/grid-item.html %}
+                {% endif %}
+            {%- endfor -%}
+
+        </ul>
+    </section>
+</section>
+{% endif %}
+
 
 
 
diff --git a/_posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html b/_posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html
new file mode 100644
index 000000000..c6611aab2
--- /dev/null
+++ b/_posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html
@@ -0,0 +1,25 @@
+---
+permalink: javascript/guides/
+description: Guides for Plotly.js, including migration guides between major versions with breaking changes and before/after examples.
+name: Guides
+layout: langindex
+display_as: guide
+language: plotly_js
+thumbnail: thumbnail/mixed.jpg
+---
+
+
+<header class="--welcome">
+	<div class="--welcome-body">
+		<div class="--title">
+			<div class="--body">
+				<h1>Plotly.js Guides</h1>
+				<p>{{page.description}}</p>
+				{% include layouts/dashplug.html %}
+			</div>
+		</div>
+	</div>
+</header>
+
+		{% assign languagelist = site.posts | where:"language","plotly_js" | where:"display_as","guide" | where: "layout","base" | sort: "order" %}
+        {% include posts/documentation_eg.html %}

From fcba9e35da0b0e92fe703300d262fa55b862b586 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Fri, 17 Jul 2026 16:36:48 -0600
Subject: [PATCH 02/25] Move v3 migration guide

---
 .../migrating-to-v3/2024-10-09-migrating-to-v3.md}                | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename _posts/plotly_js/{fundamentals/plotly-js-3-changes/2024-10-09-plotly-js-3-changes.md => guides/migrating-to-v3/2024-10-09-migrating-to-v3.md} (100%)

diff --git a/_posts/plotly_js/fundamentals/plotly-js-3-changes/2024-10-09-plotly-js-3-changes.md b/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md
similarity index 100%
rename from _posts/plotly_js/fundamentals/plotly-js-3-changes/2024-10-09-plotly-js-3-changes.md
rename to _posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md

From 696dabd8490d360e8178007093d867b52271b67a Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Fri, 17 Jul 2026 16:46:33 -0600
Subject: [PATCH 03/25] Update v3 migration guide frontmatter

---
 .../migrating-to-v3/2024-10-09-migrating-to-v3.md | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md b/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md
index dabc03d0c..a24704e16 100644
--- a/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md
+++ b/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md
@@ -1,13 +1,16 @@
 ---
 description: Learn about the changes in Plotly.js version 3.
-display_as: file_settings
+display_as: guide
 language: plotly_js
 layout: base
-name: Version 3 Changes
-order: 27
+name: Migrating to Plotly.js v3
+order: 2
 page_type: u-guide
-permalink: javascript/version-3-changes/
-redirect_from: javascript/pointcloud/
+permalink: javascript/guides/migrating-to-v3/
+redirect_from:
+- javascript/pointcloud/
+- javascript/version-3-changes/
+- javascript/migrating-to-v3/
 sitemap: false
 thumbnail: thumbnail/pointcloud.jpg
 ---
@@ -359,4 +362,4 @@ var data = [{
     cmin: 0,
     cmax: 100
 }];
-```
\ No newline at end of file
+```

From 56ecb4700ed7130062fd6f1085f96ad7c034aa5f Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Fri, 17 Jul 2026 17:06:58 -0600
Subject: [PATCH 04/25] Add v4 migration guide

---
 .../2026-07-17-migrating-to-v4.md             | 959 ++++++++++++++++++
 .../migration_antimeridian_v3.png             | Bin 0 -> 84216 bytes
 .../migration_antimeridian_v4.png             | Bin 0 -> 81653 bytes
 .../migration_geo_autofit_v3.png              | Bin 0 -> 98871 bytes
 .../migration_geo_autofit_v4.png              | Bin 0 -> 87755 bytes
 .../migration_map_autofit_v3.png              | Bin 0 -> 89209 bytes
 .../migration_map_autofit_v4.png              | Bin 0 -> 48538 bytes
 .../migrating-to-v4/migration_sankey_v3.png   | Bin 0 -> 69800 bytes
 .../migrating-to-v4/migration_sankey_v4.png   | Bin 0 -> 68596 bytes
 .../migration_scattermap_iconcolor_v3.png     | Bin 0 -> 59214 bytes
 .../migration_scattermap_iconcolor_v4.png     | Bin 0 -> 56442 bytes
 .../migration_scattermap_legendsymbol_v3.png  | Bin 0 -> 62430 bytes
 .../migration_scattermap_legendsymbol_v4.png  | Bin 0 -> 58887 bytes
 .../migration_shape_legend_swatch_v3.png      | Bin 0 -> 29802 bytes
 .../migration_shape_legend_swatch_v4.png      | Bin 0 -> 29948 bytes
 .../migrating-to-v4/migration_tickmode_v3.png | Bin 0 -> 37078 bytes
 .../migrating-to-v4/migration_tickmode_v4.png | Bin 0 -> 35021 bytes
 17 files changed, 959 insertions(+)
 create mode 100644 _posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
 create mode 100644 all_static/images/migrating-to-v4/migration_antimeridian_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_antimeridian_v4.png
 create mode 100644 all_static/images/migrating-to-v4/migration_geo_autofit_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_geo_autofit_v4.png
 create mode 100644 all_static/images/migrating-to-v4/migration_map_autofit_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_map_autofit_v4.png
 create mode 100644 all_static/images/migrating-to-v4/migration_sankey_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_sankey_v4.png
 create mode 100644 all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v4.png
 create mode 100644 all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v4.png
 create mode 100644 all_static/images/migrating-to-v4/migration_shape_legend_swatch_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_shape_legend_swatch_v4.png
 create mode 100644 all_static/images/migrating-to-v4/migration_tickmode_v3.png
 create mode 100644 all_static/images/migrating-to-v4/migration_tickmode_v4.png

diff --git a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
new file mode 100644
index 000000000..383172ad5
--- /dev/null
+++ b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
@@ -0,0 +1,959 @@
+---
+description: Learn about the changes in Plotly.js version 4.
+display_as: guide
+language: plotly_js
+layout: base
+name: Migrating to Plotly.js v4
+order: 1
+page_type: u-guide
+permalink: javascript/guides/migrating-to-v4/
+redirect_from:
+- javascript/migrating-to-v4/
+sitemap: false
+thumbnail: thumbnail/mixed.jpg
+---
+# Migrating to Plotly.js v4
+
+This guide covers breaking changes between v3 and v4 and how to update your code.
+Most figures will render without changes; the items below call out where output
+or accepted input has changed.
+
+## Contents
+
+- [Minimum Node.js version](#minimum-nodejs-version)
+- [Color library swap (tinycolor2 → color)](#color-library-swap)
+- [Chart Studio APIs removed](#chart-studio-apis-removed)
+- [Mapbox traces and subplots removed](#mapbox-traces-and-subplots-removed)
+- [Country name lookup (country-regex → country-iso-search)](#country-name-lookup)
+- [TypeScript types](#typescript-types)
+- [Scattermap icon defaults](#scattermap-icon-defaults)
+- [Map subplots auto-frame to data](#map-subplots-auto-frame-to-data)
+- [Geo subplots auto-frame by default](#geo-subplots-auto-frame-by-default)
+- [Geo `fitbounds` framing for antimeridian features](#geo-fitbounds-framing-for-antimeridian-features)
+- [Geo subplot zoom limits](#geo-subplot-zoom-limits)
+- [Shape legend marker outlines honor `line.dash`](#shape-legend-marker-outlines-honor-linedash)
+- [Overlaying axis `tickmode` defaults to `'sync'`](#overlaying-axis-tickmode-defaults-to-sync)
+- [Sankey layout algorithm update](#sankey-layout-algorithm-update)
+
+---
+
+## Minimum Node.js version
+
+*Implemented in [#7861](https://github.com/plotly/plotly.js/pull/7861).*
+
+Plotly.js now requires Node.js v22 or newer. The previous floor was v18,
+which has reached end-of-life.
+
+This only affects you if you:
+
+- build Plotly.js from source (contributors, custom bundles)
+- run Plotly.js in a Node.js runtime (server-side rendering via jsdom,
+  validation scripts, image export pipelines, etc.)
+- install via a package manager that enforces `engines` strictly
+  (`yarn`, `pnpm`)
+
+Consumers who only load the pre-built browser bundle
+(`plotly.min.js` or a partial bundle like `plotly-basic.min.js`) are
+unaffected — the bundle runs in browsers, not Node.
+
+If you're on Node 18 or 20, upgrade to 22 LTS. `npm` will print a
+warning on install but won't fail; `yarn` and `pnpm` will refuse to
+install unless your environment satisfies `engines.node >= 22.0.0`.
+
+---
+
+## Color library swap
+
+*Implemented in [#7536](https://github.com/plotly/plotly.js/pull/7536).*
+
+In v4, Plotly's internal color processing was switched from
+[tinycolor2](https://github.com/bgrins/TinyColor) to
+[color](https://github.com/Qix-/color). The new library is actively
+maintained and supports modern CSS Color 4 syntax, but a handful of
+behaviors changed in the process.
+
+### Color string inputs that no longer work
+
+**`hsv()` color strings are no longer accepted.**
+
+```js
+// Before
+{ marker: { color: 'hsv(200, 80%, 80%)' } }
+
+// After — convert to hsl, hwb, hex, or rgb
+{ marker: { color: 'hsl(200, 67%, 47%)' } }
+```
+
+A color in the unsupported format will fall back to the attribute's default.
+
+**`rgb()` / `rgba()` strings with 0–1 decimal fractions are no longer
+accepted.**
+
+```js
+// Before — tinycolor parsed this as 0–1 fractions
+'rgb(0.5, 0.5, 0.5)'  // → rgb(128, 128, 128)
+
+// After — the underlying library reads them as integer 0–255 (truncated)
+'rgb(0.5, 0.5, 0.5)'  // → rgb(1, 1, 1)
+```
+
+Convert any inputs of the form `rgb(0.5, 0.5, 0.5)` to `rgb(128, 128, 128)`
+(or any other supported color string) before passing them to Plotly.
+
+Mixed-format strings where at least one component is `>= 1` (e.g.
+`rgb(255, 0.0, 0.0)`) continue to render correctly: the new parser treats
+the `0.0` components as integer `0`.
+
+**Numeric color inputs are now rejected.**
+
+```js
+// Before — silently accepted, rendered as near-black
+{ marker: { color: 42 } }
+
+// After — falls back to the attribute default
+```
+
+If you were relying on numeric color values being coerced, convert them
+to color strings before passing them to Plotly.
+
+### Color computation output changes
+
+A handful of Plotly's derived colors shift by a few RGB units. Visible
+places where output shifts:
+
+| Where | Example |
+|---|---|
+| Heatmap auto-contrast text | A `Jet` colorscale heatmap shows text flipping between dark grey and white on mid-luminance cells in the teal/cyan band |
+| Auto-generated `insidetextfont` color on bars/waterfall | Same threshold shift around teal/cyan-ish backgrounds |
+| Sankey default hover color (dark BG) | RGB channels shift by 1 unit per channel vs v3 |
+
+### New color formats you can now use
+
+The new library accepts CSS Color 4 syntax that wasn't possible with
+tinycolor. All of these are now valid anywhere Plotly accepts a color
+string:
+
+```js
+'#ff0000aa'          // 8-digit hex with alpha
+'#f00a'              // 4-digit short hex with alpha
+'rgb(255 0 0)'       // space-separated rgb
+'rgba(255 0 0 / 0.5)' // slash-alpha rgba
+'hsl(0 100% 50% / 0.5)' // slash-alpha hsl
+'hsla(0, 100%, 50%, 0.5)' // hsla
+'hwb(0, 0%, 0%)'     // hwb (hue-whiteness-blackness)
+```
+
+See [test/image/mocks/color_syntax_formats.json](https://github.com/plotly/plotly.js/blob/master/test/image/mocks/color_syntax_formats.json)
+for a working example using each format.
+
+#### Browser compatibility
+
+All of these are parsed by Plotly in JavaScript and normalized to legacy
+`rgb(...)` / `rgba(...)` before being written to the DOM, so the browser
+never sees the modern syntax — your figures render the same in any
+browser that ran v3. The note below only matters if you also mirror these
+strings into your own stylesheets or template literals.
+
+Native CSS support:
+
+| Format | First supported |
+|---|---|
+| `#rrggbbaa`, `#rgba` | Chrome 62 (2017), Firefox 49 (2016), Safari 9.1 (2016) |
+| `rgb(r g b)`, `rgb(r g b / a)`, `hsl(h s l / a)` (space + slash-alpha) | Chrome 65 (2018), Firefox 52 (2017), Safari 12.1 (Mar 2019) |
+| `hsla()` | Universal since IE9 |
+| `hwb()` | Chrome 101 (Apr 2022), Firefox 96 (Jan 2022), Safari 15 (Sep 2021) |
+
+`hwb()` is the only format here that won't parse in browsers from ~2020
+or earlier. Everything else is safe in any browser shipped in the last
+seven years.
+
+---
+
+## Chart Studio APIs removed
+
+*Implemented in [#7812](https://github.com/plotly/plotly.js/pull/7812).*
+
+The legacy "Edit in Chart Studio" link, related config options, and the
+streaming token attribute have been removed. The `sendDataToCloud` modebar
+button and config option are retained — only the duplicate
+`editInChartStudio` button and the on-graph "Edit chart" link are gone.
+
+### Removed config options
+
+`Plotly.newPlot(gd, data, layout, config)` no longer accepts:
+
+| Removed | What it did | Replacement |
+|---|---|---|
+| `showLink` | Drew an "Edit chart" link at the bottom-right of the plot | None — remove the option |
+| `linkText` | Text for the `showLink` link | None — remove the option |
+| `sendData` | Whether the link uploaded data or just linked to a file | None — remove the option |
+| `showSources` | Hook that drew custom source links next to `showLink` | None — remove the option |
+| `showEditInChartStudio` | Pencil-icon variant of `sendDataToCloud` | Use `showSendToCloud` |
+
+```js
+// Before
+Plotly.newPlot(gd, data, layout, {
+    showLink: true,
+    linkText: 'View on Plotly',
+    showEditInChartStudio: true,
+});
+
+// After
+Plotly.newPlot(gd, data, layout, {
+    showSendToCloud: true,
+});
+```
+
+### Removed modebar button
+
+`editInChartStudio` is no longer a built-in modebar button. If you were
+adding it explicitly via `modeBarButtonsToAdd`, switch to `sendDataToCloud`:
+
+```js
+// Before
+{ modeBarButtonsToAdd: ['editInChartStudio'] }
+
+// After
+{ modeBarButtonsToAdd: ['sendDataToCloud'] }
+```
+
+### Removed trace attribute
+
+The undocumented `stream` attribute (`stream.token`, `stream.maxpoints`)
+has been removed from every trace type. It was a hook for the Chart
+Studio streaming service, which is no longer reachable. If you have
+figures containing `stream: { token: '...', maxpoints: N }` in their
+trace objects, delete those properties — they're now schema-rejected.
+
+---
+
+## Mapbox traces and subplots removed
+
+*Implemented in [#7860](https://github.com/plotly/plotly.js/pull/7860).*
+
+The legacy mapbox-gl-js–based traces and subplot type have been removed.
+The MapLibre-based `map` family that has shadowed them since v2 is now
+the only map implementation.
+
+### Removed
+
+| Removed | Replacement |
+|---|---|
+| `scattermapbox` trace | `scattermap` |
+| `choroplethmapbox` trace | `choroplethmap` |
+| `densitymapbox` trace | `densitymap` |
+| `layout.mapbox` subplot (and `mapbox2`, `mapbox3`, …) | `layout.map` (and `map2`, `map3`, …) |
+| `layout.mapbox.accesstoken` | None — MapLibre uses open tile providers |
+| `mapboxAccessToken` config option | None — see above |
+| `plotly-mapbox.min.js` partial bundle | `plotly-map.min.js` |
+| Modebar buttons `zoomInMapbox`, `zoomOutMapbox`, `resetViewMapbox` | `zoomInMap`, `zoomOutMap`, `resetViewMap` |
+| `scrollZoom` flag value `'mapbox'` (e.g. `scrollZoom: 'mapbox+cartesian'`) | `'map'` |
+
+The schema for `map` mirrors `mapbox` attribute-for-attribute (`domain`,
+`style`, `center`, `zoom`, `bearing`, `pitch`, `bounds`, `layers[...]`),
+so the migration is usually a rename.
+
+```js
+// Before
+{
+    data: [{ type: 'scattermapbox', lon: [...], lat: [...] }],
+    layout: {
+        mapbox: {
+            style: 'open-street-map',
+            center: { lon: 0, lat: 0 },
+            zoom: 2,
+        },
+    },
+    config: { mapboxAccessToken: 'pk.eyJ1...' },
+}
+
+// After
+{
+    data: [{ type: 'scattermap', lon: [...], lat: [...] }],
+    layout: {
+        map: {
+            style: 'open-street-map',
+            center: { lon: 0, lat: 0 },
+            zoom: 2,
+        },
+    },
+    // mapboxAccessToken removed — MapLibre needs no token for the
+    // built-in styles
+}
+```
+
+### Built-in style values
+
+Every built-in `style` name that worked on `mapbox` still works on `map`,
+but the tiles backing them differ — visual output **will change** even
+when no other figure changes:
+
+| Style name | Old (`mapbox`) | New (`map`) |
+|---|---|---|
+| `basic`, `streets`, `outdoors` | mapbox.com vector tiles (required token) | Carto Voyager |
+| `light` | mapbox.com light | Carto Positron |
+| `dark` | mapbox.com dark | Carto Dark Matter |
+| `satellite`, `satellite-streets` | mapbox.com satellite | ArcGIS World Imagery |
+| `white-bg`, `open-street-map` | unchanged | unchanged |
+| `carto-*`, `carto-*-nolabels` | n/a (already open) | unchanged |
+
+The three Stamen styles (`stamen-terrain`, `stamen-toner`,
+`stamen-watercolor`) are gone — Stamen tiles now require a Stadia API
+key. Users who need them can supply a custom `style` URL.
+
+### Custom style URLs
+
+Custom MapLibre / Mapbox-style JSON URLs continue to work. The
+`mapbox://styles/mapbox/...` short form is no longer resolved, since it
+requires authenticating to mapbox.com. Substitute the full URL of an
+equivalent open style, or self-host the style JSON.
+
+### Static export
+
+The Mapbox logo previously injected into static SVG / PNG exports of
+mapbox subplots is no longer drawn — MapLibre has no equivalent
+trademark requirement. Attribution provided by tile sources (Carto,
+OpenStreetMap, ArcGIS) is still rendered inside the map canvas.
+
+---
+
+## Country name lookup
+
+*Implemented in [#7856](https://github.com/plotly/plotly.js/pull/7856).*
+
+`locationmode: 'country names'` on `choropleth` and `scattergeo` traces is
+now resolved by [country-iso-search](https://github.com/plotly/country-iso-search)
+instead of [country-regex](https://github.com/etpinard/country-regex). The
+attribute name, accepted values list, and ISO-3 output are unchanged —
+the difference is in *how* a name string is matched to an alpha-3 code.
+
+The old library walked a table of country-specific regular expressions
+and returned the first match. That made it lenient (substring matches
+worked) but ambiguity-prone — strings like `'Republic of'` could
+resolve to whichever entry's regex hit first. The new library does a
+sanitized exact lookup against a curated alias table, which is stricter
+about ambiguous input but accepts many more legitimate forms.
+
+### Names that resolved before but no longer do
+
+Strings that only matched because of overly broad regex fragments now
+fall back to the unrecognized-name log message and the location is
+skipped. In practice this hits inputs that weren't really country
+names — partial phrases, generic descriptors, or strings containing a
+country name as a substring of something else (e.g.
+`'Republic of Foo'`, `'Not Iran'`). If you were relying on a
+non-canonical form, switch to the country's name, an alias, or the
+ISO-3 / ISO-2 code.
+
+### Names and forms that now resolve
+
+The alias table is larger and the input is normalized before lookup,
+so a number of forms that previously failed now work:
+
+```js
+// All resolve to 'FRA'
+'France'
+'FR'                        // ISO 3166-1 alpha-2
+250                         // UN M49 numeric (number or string)
+'\u{1F1EB}\u{1F1F7}'        // flag emoji
+
+// Historical / native / punctuated names
+'Burma'                     // → 'MMR'
+'Türkiye'                   // → 'TUR' (diacritics stripped)
+'Cote d\'Ivoire'            // → 'CIV' (apostrophes ignored)
+'St. Kitts and Nevis'       // → 'KNA' ('St.' expands to 'Saint')
+'The Gambia'                // → 'GMB' (leading 'The ' dropped)
+```
+
+Matching is case-insensitive. Sanitization also collapses internal
+whitespace, drops `.` `()` `,`, maps `&` → `and`, and turns `-` / `–` /
+`—` into spaces — so cosmetic punctuation differences in your input
+data no longer block a match.
+
+### Disputed-territory codes are retained
+
+The user-assigned alpha-3 codes Plotly historically recognized for
+disputed regions still work:
+
+| Code | Region |
+|---|---|
+| `XAC` | Aksai Chin |
+| `XAP` | Arunachal Pradesh |
+| `XBT` | Bir Tawil |
+| `XHT` | Halaib Triangle |
+| `XJK` | Jammu and Kashmir |
+
+These are layered on top of the standard ISO 3166-1 records via
+[src/lib/custom_country_codes.ts](https://github.com/plotly/plotly.js/blob/master/src/lib/custom_country_codes.ts).
+Whether a feature for them appears on the rendered map still depends
+on the topojson resolution in use.
+
+---
+
+## TypeScript types
+
+*Implemented in [#7680](https://github.com/plotly/plotly.js/pull/7680) and [#7868](https://github.com/plotly/plotly.js/pull/7868).*
+
+Plotly.js now ships its own TypeScript type definitions. `package.json`
+points `"types"` at `lib/index.d.ts`, so the types are picked up
+automatically — no separate `@types/*` install is needed.
+
+### Importing
+
+The package exports a default namespace, named exports, and a global
+`Plotly` namespace:
+
+```ts
+import Plotly from 'plotly.js';
+// or
+import * as Plotly from 'plotly.js';
+// or
+import { newPlot } from 'plotly.js';
+import type { Layout, Data, TraceType } from 'plotly.js';
+```
+
+A minimal typed example:
+
+```ts
+import { newPlot } from 'plotly.js';
+import type { Data, Layout } from 'plotly.js';
+
+const data: Data[] = [{ type: 'scatter', x: [1, 2, 3], y: [4, 5, 6] }];
+const layout: Partial<Layout> = { title: { text: 'Demo' } };
+
+await newPlot(div, data, layout);
+```
+
+### What's exported
+
+**Trace data** — `Data` (the union of every trace's typed data object),
+plus per-trace interfaces like `ScatterData`, `BarData`, `HeatmapData`,
+`ChoroplethData`, etc. Each per-trace interface narrows on `type`, so
+using `Data[]` in your figure lets TypeScript pick the right trace
+shape from the literal `type` value:
+
+```ts
+const data: Data[] = [
+    { type: 'bar', x: ['a', 'b'], y: [1, 2] },     // checked as BarData
+    { type: 'scatter', x: [1, 2], mode: 'lines' }, // checked as ScatterData
+];
+```
+
+Other exports:
+
+- **Layout** — `Layout` (the full layout interface), `LayoutAxis`,
+  `Legend`, `Annotation`, `Shape`, `Slider`, `UpdateMenu`, `Scene`, and
+  the rest of the component interfaces. Pass `Partial<Layout>` to
+  `newPlot` / `react` since most fields are optional.
+
+- **Config** — `Config`, `ToImgopts`, `ToImageButtonOptions`,
+  `DownloadImgopts`, `ModeBarDefaultButtons`, `ModeBarButton`, `Icon`.
+
+- **Trace/layout enums** — string-literal unions like `TraceType`,
+  `AxisType`, `Calendar`, `Dash`, `PatternShape`, `XRef`, `YRef`,
+  `MarkerSymbol`, `HoverInfo`, etc. Use these instead of bare `string`
+  to get narrowing on attribute values.
+
+- **Shared sub-interfaces** — `Font`, `ColorBar`, `HoverLabel`,
+  `Pattern`, `Domain`, `LegendGroupTitle`, `TickFormatStops`, etc.,
+  used wherever the schema reuses the same sub-attribute tree.
+
+- **Events** — `PlotMouseEvent`, `PlotHoverEvent`, `PlotSelectionEvent`,
+  `PlotRelayoutEvent`, `PlotRestyleEvent`, `LegendClickEvent`,
+  `SliderChangeEvent`, etc., plus `PlotlyEventName` for the union of
+  event names accepted by `on()` / `once()` / `removeListener()`.
+
+- **Animation & frames** — `AnimationOpts`, `Frame`, `Transition`,
+  `TransitionEasing`.
+
+- **Templates** — `Template` interface (and `TemplateFigure`,
+  `ValidateTemplateResult` from the template utilities).
+
+- **DOM** — `PlotlyHTMLElement` (the typed `Plotly.newPlot` graph
+  div), `Datum`, `TypedArray`, `Color`, `ColorScale`.
+
+### Notes on a few types
+
+**`Data` vs per-trace interfaces.** Prefer the `Data` union for figure
+literals (TypeScript discriminates on `type`); use the per-trace
+interface only when you have a value that is *guaranteed* to be one
+trace type — e.g. a helper that builds a `BarData` to push into a
+`Data[]`.
+
+**`Layout` is the input shape, not the resolved shape.** It mirrors
+what you pass to `newPlot`. The post-coerce internal shape used inside
+Plotly's own code (often called "FullLayout") is intentionally not
+exported. Likewise `Data` is the input shape; resolved trace state
+("FullData") is internal.
+
+**`PlotType` is an alias for `TraceType`.** Both name the same
+string-literal union of trace type names; existing code that imports
+`PlotType` keeps compiling. New code should prefer `TraceType`.
+
+---
+
+## Scattermap icon defaults
+
+*Implemented in [#7825](https://github.com/plotly/plotly.js/pull/7825).*
+
+If you used `scattermap` or `scattermapbox` in v3, three rendering details
+have changed by the time you land on `scattermap` in v4:
+
+### Marker icons now respect `marker.color`
+
+`marker.color` on a scattermap trace is now applied to the icon by
+setting `icon-color` (plus a small `icon-halo` so the colored edges
+read cleanly). In v3 the property was set on the layer but the
+underlying icons weren't SDF sprites, so the color had no visible
+effect — coloring was effectively a no-op.
+
+In v4 the Maki icons are loaded with `{sdf: true}` and tinted with
+`marker.color`. Figures relying on the icon retaining its original
+artwork color will now render in the trace color. If you need the
+original tint, pick a Maki icon already in that color and set
+`marker.color: 'white'` (which becomes the identity tint for SDF
+sprites).
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 scattermap icons uncolored](/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v3.png) | ![v4 scattermap icons tinted red](/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v4.png) |
+
+### Maki icon set updated to v8 (via jsDelivr)
+
+The icon CDN and version have changed:
+
+- **v3**: `https://unpkg.com/maki@2.1.0/icons/<name>.svg`
+- **v4**: `https://cdn.jsdelivr.net/npm/@mapbox/maki@8.2.0/icons/<name>.svg`
+
+A handful of icon names removed between Maki 2.1 and 8.2 will now
+silently fail to load (HTTP 404). If you were using one of the dropped
+icons, swap it for the nearest Maki 8 equivalent (see
+[Maki 8 icon list](https://labs.mapbox.com/maki-icons/)).
+
+### Legend swatch always renders as a circle
+
+`scattermap` legend swatches now always draw a circle, regardless of
+`marker.symbol`. In v3 the swatch went through the same code path as
+cartesian traces, which only understands the
+[Plotly-supported symbol names](https://github.com/plotly/plotly.js/blob/master/src/components/drawing/symbol_defs.js).
+On map traces, that produced inconsistent output: symbols with names
+that don't overlap the Plotly set (Maki-only names like `'airport'`,
+`'cafe'`) rendered as filled circles, while other symbols (`'square'`,
+`'star'`, etc.) rendered as broken/empty paths in the legend even
+though they draw correctly on the map. The v4 circle fallback makes
+the swatch consistent across every scattermap trace.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 scattermap legend inconsistent](/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v3.png) | ![v4 scattermap legend all circles](/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v4.png) |
+
+If you were styling the legend swatch path directly based on
+`marker.symbol`, that selector will now always match a circle path on
+map traces.
+
+---
+
+## Map subplots auto-frame to data
+
+*Implemented in [#7884](https://github.com/plotly/plotly.js/pull/7884).*
+
+`map` subplots now auto-frame the view to fit the trace data. In v3, the
+same layout produced a world view centered at `(0, 0)` with `zoom: 1`,
+requiring the user to supply `center` and `zoom` (or drag/scroll) to see
+their data.
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'scattermap',
+    lon: [-122.4, -73.9, -87.6],
+    lat: [37.8, 40.7, 41.9]
+}], {
+    map: { style: 'basic' }
+});
+// v3: map opens centered at (0, 0) at zoom 1
+// v4: map opens framed on the three cities
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 map with world view](/all_static/images/migrating-to-v4/migration_map_autofit_v3.png) | ![v4 map framed on cities](/all_static/images/migrating-to-v4/migration_map_autofit_v4.png) |
+
+Auto-framing runs on the initial render and again on data-only updates
+(`Plotly.restyle` of `lon`/`lat`, `Plotly.addTraces`, `Plotly.deleteTraces`)
+whenever the user hasn't overridden the view. Once the user pans, zooms,
+rotates, or tilts the map — or explicitly sets `center` / `zoom` / `bearing`
+/ `pitch` in the layout — auto-framing steps aside and preserves the
+chosen view across further data changes.
+
+### Opting out
+
+Two ways to disable auto-framing.
+
+**Set `map.fitbounds: false`** — recommended for intentional opt-out;
+explicit and independent of the view values.
+
+```js
+{ map: { fitbounds: false } }
+```
+
+**Set `map.center` or `map.zoom` explicitly** — any value counts as
+user intent, including `zoom: 0` and `center: { lon: 0, lat: 0 }`.
+
+```js
+// Keep the v3 world view:
+{ map: { center: { lon: 0, lat: 0 }, zoom: 1 } }
+```
+
+### Which traces contribute
+
+Each `map` subplot auto-frames independently, using only the
+`scattermap` and `densitymap` traces assigned to it (via the trace's
+`subplot` attribute). Each contributing trace's `lon` / `lat` arrays
+feed the frame, with non-finite entries skipped. Traces belonging to
+a different subplot (`map2`, `polar`, etc.) are framed by their own
+subplot, not this one; traces with `visible !== true` are ignored
+entirely.
+
+**`choroplethmap` traces skip auto-framing** because they carry
+`locations` / `geojson` rather than point lon/lat, so their extent
+can't be included without geojson bbox handling. When a visible
+`choroplethmap` sits on the subplot, the view falls back to the v3
+default. Set `map.center` and `map.zoom` explicitly to frame the choropleth.
+
+### Antimeridian data
+
+For data that straddles the antimeridian (points on both sides of ±180°),
+the auto-frame picks the compact crossing range rather than the
+long-way-around view. For example, `lon: [131.8855, -179]` frames as
+`[131.8855, 181]` (a ~49° span across the antimeridian) instead of the
+naive `[-179, 131.8855]` (~311° the wrong way).
+
+### `map.bounds` is unaffected
+
+The `map.bounds` layout attribute (which restricts panning) is a
+separate concern and continues to work as in v3. Auto-framing computes
+the *initial* view; `bounds` constrains *interactive* view movement.
+Both can coexist.
+
+### Relationship to `layout.geo.fitbounds`
+
+Both `map` and `geo` subplots now expose a `fitbounds` layout attribute,
+but the shapes differ:
+
+| | `map.fitbounds` | `geo.fitbounds` |
+|---|---|---|
+| Type | boolean | enumerated |
+| Values | `true` / `false` | `false` / `'locations'` / `'geojson'` |
+| Default | `true` | `'locations'` (was `false` in v3 — see [Geo subplots auto-frame by default](#geo-subplots-auto-frame-by-default)) |
+| Re-fits on data updates | yes, until user overrides view | yes, every render |
+
+If you use both subplot types in one figure, note that `map.fitbounds` is
+a straight on/off toggle, while `geo.fitbounds` also selects *what*
+contributes to the frame (visible `locations` only, vs. the entire trace
+`geojson`).
+
+---
+
+## Geo subplots auto-frame by default
+
+*Implemented in [#7895](https://github.com/plotly/plotly.js/pull/7895).*
+
+`layout.geo.fitbounds` now defaults to `'locations'` (v3 default: `false`).
+`geo` subplots — used by `scattergeo`, `choropleth`, and any other
+location-based geo trace — now auto-frame their initial view to fit the
+trace data, matching the behavior of `map` subplots. Figures that previously
+rendered the full world map (or the scope's default extent) now zoom to just
+the locations they plot.
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'choropleth',
+    locations: ['CAN', 'MEX'],
+    z: [1, 2]
+}], {
+    // v3: full world map (fitbounds defaulted to false)
+    // v4: tight fit around Canada and Mexico (fitbounds now defaults to 'locations')
+});
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 geo world view](/all_static/images/migrating-to-v4/migration_geo_autofit_v3.png) | ![v4 geo framed on Canada+Mexico](/all_static/images/migrating-to-v4/migration_geo_autofit_v4.png) |
+
+### How to opt out
+
+Two paths:
+
+**Explicit:** set `layout.geo.fitbounds: false` to restore the v3 default view.
+
+```js
+Plotly.newPlot(gd, [/* ... */], {
+    geo: { fitbounds: false }  // world view / scope-default view, as in v3
+});
+```
+
+**Implicit:** setting any of the view attributes that auto-fit would
+otherwise compute automatically disables auto-fit for that figure. Which
+attributes count depends on the projection:
+
+| Projection kind | Projection-specific opt-out attributes |
+|---|---|
+| Any non-`world` scope (checked first, even if the projection is also clipped) | `center.lon`, `center.lat`, `projection.scale` |
+| World scope + clipped projection (orthographic, azimuthal equal area, etc.) | `center.lon`, `center.lat`, `projection.scale`, `projection.rotation.lon`, `projection.rotation.lat` |
+| World scope, non-clipped projection (miller, robinson, mercator, etc.) | `center.lon`, `center.lat`, `projection.scale`, `projection.rotation.lon` |
+
+In addition to the projection-specific set above, setting either
+`lonaxis.range` or `lataxis.range` always disables auto-fit for that
+figure, regardless of projection type. Even for projections where
+fitbounds doesn't overwrite the ranges directly, the fitted
+`center`/`scale` would visually override whatever framing the ranges
+imply, so we treat setting a range as opt-out intent.
+
+Under the v4 default this means figures that supplied their own view
+attributes in v3 continue to render with those attributes — no code change
+needed. Auto-fit only kicks in when none of the relevant attributes are set.
+
+```js
+Plotly.newPlot(gd, [/* ... */], {
+    geo: {
+        projection: { rotation: { lon: -75 } }
+        // fitbounds is implicitly false because rotation.lon is set
+    }
+});
+```
+
+This differs from v3, where `fitbounds: 'locations'` would overwrite any
+user-supplied view attributes. In v4 the two are treated as opt-in to
+different framing modes: auto-fit or explicit view.
+
+### Projections that don't participate in auto-fit
+
+Three projection types skip auto-fit and render with the schema default
+view even when `fitbounds` is unset (i.e., defaulted to `'locations'`):
+
+- `'albers usa'` — a fixed composite projection with predetermined insets
+  for Alaska and Hawaii; it has no `center`/`rotation` concept for fitbounds
+  to target.
+- `'craig'` and `'satellite'` — the internal scale heuristic that drives
+  `fitbounds` compares data bounds against world bounds in the projected
+  plane, which is unreliable for these projections' non-linear (and,
+  for satellite, perspective-dependent) mapping. Auto-fit would zoom
+  incorrectly, so v4 skips it.
+
+For these projections `layout.geo.fitbounds` is silently forced to `false`
+in the resolved layout even if you leave it at the default. To fit
+locations under one of these projections, supply the view attributes
+yourself (`center`, `projection.rotation`, `projection.scale`, etc.).
+
+### Reset button behavior
+
+The modebar's Reset view button restores the auto-fit view when
+`fitbounds` is active, not the schema default. Prior to v4 there was no
+auto-fit default, so Reset simply restored the schema default; in v4 the
+initial view captured for reset is the fitted view.
+
+---
+
+## Geo `fitbounds` framing for antimeridian features
+
+*Implemented in [#7891](https://github.com/plotly/plotly.js/pull/7891).*
+
+`layout.geo.fitbounds: 'locations'` (and `'geojson'`) now correctly frames
+choropleth and scattergeo location traces containing features that cross the
+±180° antimeridian — Russia, Fiji, Antarctica, New Zealand, and the Aleutian
+Islands portion of Alaska. In v3 these were mis-framed because the underlying
+bounding-box computation (`@turf/bbox`) reported a bogus whole-globe span
+(`[-180°, 180°]`) for any such feature, and the fit zoomed the map out to
+match. In v4, `computeBbox` uses `d3-geo.geoBounds`' widest-gap longitude
+algorithm on the feature's vertices and returns the compact crossing range
+(with `east > 180°` when the range wraps).
+
+Because v4 also flips the `fitbounds` default from `false` to `'locations'`
+(see [Geo subplots auto-frame by default](#geo-subplots-auto-frame-by-default)),
+figures that never set `fitbounds` explicitly now participate in auto-fit
+too — so this antimeridian fix reaches many more figures than it would
+have as a standalone change.
+
+### Which figures shift
+
+A figure sees a visible change when **both** of the following hold:
+
+- `layout.geo.fitbounds` is active — either explicitly set to `'locations'` /
+  `'geojson'`, or left at the v4 default (see the opt-out list in the
+  auto-fit-default section above), and
+- The figure contains a `choropleth` or `scattergeo` trace with `locations`
+  where at least one location resolves to a feature that crosses ±180°.
+
+Figures that opt out of auto-fit (`fitbounds: false`, an explicit view
+attribute, or one of the projections listed as skipping auto-fit), or that
+don't include an antimeridian-crossing feature, render identically to v3
+as far as this fix is concerned.
+
+### Example
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'choropleth',
+    locations: ['RUS'],
+    z: [1],
+    colorscale: [[0, '#c33'], [1, '#c33']],
+    showscale: false
+}], {
+    geo: { fitbounds: 'locations', projection: { type: 'equirectangular' } },
+    width: 700,
+    height: 500
+});
+// v3: fits to a bogus [-180°, 180°] span — Russia is a small red strip at
+//     the top of the whole world.
+// v4: fits tightly to Russia's actual longitudinal extent (~19° through
+//     ~190°, unwrapped across the antimeridian).
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 Russia mis-framed with empty space](/all_static/images/migrating-to-v4/migration_antimeridian_v3.png) | ![v4 Russia tightly framed](/all_static/images/migrating-to-v4/migration_antimeridian_v4.png) |
+
+---
+
+## Geo subplot zoom limits
+
+*Implemented in [#7371](https://github.com/plotly/plotly.js/pull/7371).*
+
+Geo subplots accept two new attributes for clamping interactive zoom:
+
+| Attribute | Default | Effect |
+|---|---|---|
+| `layout.geo.projection.minscale` | `0` | Lower bound on zoom, expressed as a multiplier of `projection.scale`. `0` means no lower bound. |
+| `layout.geo.projection.maxscale` | `null` | Upper bound on zoom, expressed as a multiplier of `projection.scale`. `null` means no upper bound. |
+
+```js
+Plotly.newPlot(gd, [/* … */], {
+    geo: {
+        projection: {
+            scale: 1,
+            minscale: 0.5,   // can't zoom out past 50% of base
+            maxscale: 4,     // can't zoom in past 400% of base
+        },
+    },
+});
+```
+
+The defaults preserve v3 behavior — figures that don't set these
+attributes are unaffected.
+
+One init-time wrinkle: if `projection.scale` falls outside
+`[minscale, maxscale]`, Plotly now dispatches a synthetic zoom event on
+first plot to clamp it back into range. That emits a
+`plotly_relayout` event that v3 wouldn't have fired. If you have a
+listener that distinguishes user-driven zooms from programmatic ones,
+make sure it tolerates a single extra event at startup for figures
+whose initial `projection.scale` is outside the configured bounds.
+
+---
+
+## Shape legend marker outlines honor `line.dash`
+
+*Implemented in [#7845](https://github.com/plotly/plotly.js/pull/7845).*
+
+Shapes rendered in the legend as filled markers (e.g. `type: 'rect'`,
+`'circle'`, or filled paths with `showlegend: true`) now draw the
+marker's outline using the shape's `line.dash` value. In v3 the marker
+outline was always solid regardless of the shape's dash style, so the
+swatch didn't match the shape on the plot. (Line-only shapes —
+`type: 'line'` — already drew their swatch dashed in v3; only the
+filled-marker path was hardcoded to solid.)
+
+```js
+Plotly.newPlot(gd, [], {
+    shapes: [{
+        type: 'rect',
+        x0: 0, x1: 1, y0: 0, y1: 1,
+        line: { dash: 'dot' },
+        fillcolor: 'rgba(200,0,0,0.2)',
+        showlegend: true,
+    }],
+});
+// v3: legend marker outline is solid
+// v4: legend marker outline is dotted, matching the on-plot shape
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 shape legend outlines solid](/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v3.png) | ![v4 shape legend outlines dashed](/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v4.png) |
+
+---
+
+## Overlaying axis `tickmode` defaults to `'sync'`
+
+*Implemented in [#7684](https://github.com/plotly/plotly.js/pull/7684).*
+
+An axis that overlays another axis (`layout.xaxis2.overlaying: 'x'`,
+`layout.yaxis2.overlaying: 'y'`, etc.) now defaults its `tickmode` to
+`'sync'` instead of `'auto'`. The overlay axis draws tick marks and
+gridlines at the same positions as its base axis, computing labels to
+match — rather than picking its own auto-fit tick positions.
+
+In v3 the two axes drew independent auto-tick grids, producing
+staggered gridlines that were hard to read and left no visual
+association between a gridline and a specific axis. Sync eliminates
+that overlap.
+
+```js
+Plotly.newPlot(gd, [
+    { y: [1, 3, 2], name: 'A' },
+    { y: [100, 300, 200], name: 'B', yaxis: 'y2' }
+], {
+    yaxis2: { overlaying: 'y', side: 'right' }
+    // v3: y2 picks its own ticks, producing a staggered grid
+    // v4: y2 places ticks at y's tick positions, with y2-range labels
+});
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 staggered overlay ticks](/all_static/images/migrating-to-v4/migration_tickmode_v3.png) | ![v4 sync'd overlay ticks](/all_static/images/migrating-to-v4/migration_tickmode_v4.png) |
+
+### Exception: categorical / multicategory base axes
+
+When the overlaid (base) axis is `type: 'category'` or `'multicategory'`,
+`tickmode` continues to default to `'auto'` on the overlaying axis.
+Sync'ing tick positions to category slots is almost never the intent.
+
+### Opting out
+
+Set `tickmode: 'auto'` (or any other explicit value) on the overlaying
+axis to restore v3 behavior:
+
+```js
+{ yaxis2: { overlaying: 'y', side: 'right', tickmode: 'auto' } }
+```
+
+### Incidental bugfix
+
+`showexponent`, `showtickprefix`, and `showticksuffix` values of
+`'first'` and `'last'` were previously ignored on axes rendered with
+`tickmode: 'sync'`. Any workaround for that (e.g., forcing `'all'` on
+overlay axes) is no longer needed in v4.
+
+---
+
+## Sankey layout algorithm update
+
+*Implemented in [#7830](https://github.com/plotly/plotly.js/pull/7830).*
+
+`@plotly/d3-sankey` has been upgraded from 0.7.2 to 0.12.3. The schema
+and API surface for `sankey` traces are unchanged — every attribute
+that worked in v3 still works in v4 — but the underlying layout
+algorithm was rewritten upstream across these versions, so node and
+link positions for the same figure shift.
+
+The most visible effect is that links tend to be straighter and cross
+each other less: the new relaxation step gives more weight to
+minimizing link travel between columns, so flows that previously
+swooped across the diagram now run closer to horizontal. Node
+y-positions within a column shift to accommodate this, and exact node
+heights / paddings can differ by a few pixels.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 sankey with crossing links](/all_static/images/migrating-to-v4/migration_sankey_v3.png) | ![v4 sankey with rewritten layout](/all_static/images/migrating-to-v4/migration_sankey_v4.png) |
diff --git a/all_static/images/migrating-to-v4/migration_antimeridian_v3.png b/all_static/images/migrating-to-v4/migration_antimeridian_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..3782747b17d5ca061e65c44f8b864da78b8e5922
GIT binary patch
literal 84216
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
Ee>a+Ui2wiq

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_antimeridian_v4.png b/all_static/images/migrating-to-v4/migration_antimeridian_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..8dd61c50241233d5f933761c4588b50aea0948b9
GIT binary patch
literal 81653
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

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_geo_autofit_v3.png b/all_static/images/migrating-to-v4/migration_geo_autofit_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..01157d91951ae99fd8f709772f8628fb518062fe
GIT binary patch
literal 98871
zcmZTw1ymf(vff35yK6!qxJz&dArRc%-Q9Hw0TP^`!3pjTi@RGwa0u@1E^qk%ckjFZ
zeW%ai3_II1)zzh6Rqs~?ISDjmVq_2qg!WPLy%Gon(+mQEJ6|9?f8s@K4+3F=KE4-K
z@c{3qA*ISqKJ^KYq4u^aPxWHQn`nLck+W~O&u^@6OsgF#D#?)hnf20F{k_$De(HEB
zQ`xZnyF>q_t)&a^aLsfg4&&gpjp3HDhOP7s?=iuxvj?BHEuA*$%Zzx)e~orDMzHX#
zzZ%Tn<68-43EbbqP6bJ$-8)-IbDo(2{2wFWT5=hoxesQM<Tz`NMiWWnALCvg2LJd`
z9{+M!s$Htx9cd=+UyoLUq5A;b%S)0lWw4?)`1gpue{EnLhyB_BY%k>@RTuex-~apS
zBmn~7e1f0W^6S5!rv@|q{5Cz|+4*m!a7ra`qZz{G@F@5N*3)H0+Vy2t(`BXPf?nG#
zSBqipDF_(kC16;D?!Ct`p*xvBjjqZO#9R|qrqX0WK5zAI-n;)!)b}eKjAz(e?g;!v
z{gusczRtEttG3ARdL@MLH+7Hr+{rHqiXN?rS^*56vj`HNqK~mObM^KaB=NL;8Gg4P
zCyP{ZoaEwQZ1Rxkz$uCG?XEEZ>C@u-bqWjtaZCa7LO1XAeNKYF9DxXEN>7gus(CU*
zEf1ITT9roP-?;6r4*w9dn|zUqr_bee-lSz@l+mm<lRfA2xtLV<I&9c7V%l2m2_t4R
z`b_SB@A${}>Q7}}TMV|zaFSv`K)~tMmHdR+AJ45cuhp+_IBjNFv%;yZ47r_wy$isl
z1EY8-uNyaYFxaLf?o%riDp9wb4l;PH$4IywwOs9Hg^(+S;WM2dcVSpx>`s2vdeZm1
z5r+(N+s@HCZw}Kd<w*WW^xqk$F4e5=&3AhB>Q#;Vksg=*;zIs8kJ1nRL#P-_>-7((
z_5PUc5v#eH!pFxu`%>K|?q5Sy@XsQWBLIj~%4z!d(#m*|A5xjh`EtS35jy=D{*RW!
zw|i5iVLm&j_A=9u(IKo~sf?Oc?_a)r*$W@A_Cq`@j$XB>SSjPJ<2#n-<4?pqb|qT1
zR&<=4Dot(&*iWDaF;cUu5uT;>`~ei_hue$2kt6%IhbdM+kfRQnLz_meReZzdBax5~
z)azn*<FVOCr_rTw;K=EHPVC{ICKSrOMm`1RHY#ckVd3j#*e;>1p~SKKURBT)#@Sk%
zaMI&|apz~Gr=I(#l|SxFs=y1Lo<h#9CJL25`~nI5rZM61zO>mIe0t0f^qvxUBf{-;
zFjJX*gGP9-U&Jux<4b<18-hW>%?uYtz~Yw8OyOu<sFWM($l$o)yxblzG_8nFBcE=g
zBX1#gcX?22*oEMnX5G=zk<4lN?dITdh3E98Fi#|v6DgkyZT`DfTK$-e%7&y*Pcuc@
z09#*&!!a()67tUJl)%{$A}w2oHg#4S_mx@v1|&J2PMM}_RnM{G#&L6)2v!NC%33O?
zQuCC^qHm`|aoG0cherBVfy;Udw;lE8mM;#Z&U`HW_OR&)bs0X%OMo1!-v7z(=H>?J
zcqUhxz?meRA?sZb@+Qwk$N@a=+OEQn_ed?byTzSLzh6Uxh3#7|63BgyMR90j6)KH-
zik+GrRz9^pJ$lD8YM!3fB9eQERE$H^d9d3<NP4$2{0~2Tr^;+`*%{v?W&MK6ZNFH;
z=ekSij!bv~h`r?k)R89QiemTrq>lmxbTcl^Lg#+Cu$ah_ad#`gytJIEpgt$xl$N1>
zAF|Td62z&lbA5z}Ja~U|cCnouMVw))VUUhxd*vbUPN?RjZGH22CqILj2hXQg_VXE{
z=?mV*Q^y}JV}e%}fatwDysztcwpUW^@qosby;j=)rM4hNX-Ey?mxx@<Gi=8fK@e84
zr@_y|+B_I|lYxtpmF~IuolqAU^y+uMyn6PBi1P_$d7|Tm3PZ67B90HNv2l9{NsYSb
zDJUAn>gDMU*~_Gv{I+wPJeoBU3rxve)@Hk~d#J1k6>Huk2eL>$;HOpRtx+U}Ei*I)
zxMBO*s-E{RwcE+rZ`PuO-!H>J4yX0~xmthSe;{Ayaog9R5?+wxbJ@;(e7Hji#z#nZ
zvAe!n@{iClR5TQdN%0;L?A`E$UO^@BzbXo+$B;;nfl_sx*P5d$MnN_uFIbys-<%Vf
zu>0M6#NvX6R;y#*$R{s(U+%N9TmH-pI3eMQ8KuB|x&8v`=9m2BzTg<*Xg^zN9CBm(
z^tZK#Vpl+><39^(0TM`vRPpo0=FgOtKuePlnD*F@=Svyp8NO3cQc!a!9)lSn|4h>p
zv%V|n7?5B|)1icxRbrv^AQXbuSBEL~t-lWHm&yRC(v6f)<E#Dj>C<X0F-3dg8+mdv
zx8ajS4w-eFIVr4~C@OFs-Wfk6Vu^Kh0%>;9Yp?Xv$m>N@UPFPK7R%o>e_W?^gLl^J
zNkFZs&S}{s3UU_Jcl<@hI_VPYci_U=YI6c+l0&Z1YLkH<P8)*_it41EdE`-jPz?`#
z(7F;q9PAuQbP&-SG-i6%izva%q*-cMwM36~v8Ce#+tF0shS&B4$T)_7t$*PhSpHSs
z5sVs04MtrWRF9y+o!Ann8;&Z}fWiZYVC=s>gl8?f&RUggzvu^3=&yprNn2o-2kv+>
z;SsP9X8A!7(9)u1HXovnAw32Xk|JPn(fWVLD(1?TyiKf?OW{7i6JH)(u~Y1gB!CK-
z^hbBFE|$%bi-Zgt<~I=aa$8T8r0QV_kVjRS4(0hj-fV?lr#=O=F}$LB_%d|%#iiJh
z&d?lAgc*dFm+bdW$EAt=Smq-EDXC3*$eoU1>A+KY+ao*50t_r{1j7qQs5fX=5jPsK
z?W=?#h}8Ko_<ZMgin99QX2^r_Uv7F?a@h>FSuXa#|Jj$!yauf$FsL*80)Fw6Yu7q?
z+V?qrmO6wrp5<`kbr37nVSfx2Y1xYyQFc(sL7s#07t$HzgU}SJhjy~Ho2?9j63Vc}
z1SV}WH&qDTxg0SWEV1fC^U>MG0(^1IJc2@CVfPggD8w>Dz_H7LNFT(%^X1KQBp7G7
z!5w7N`P!Q!O$ShGQX^DHPjW?5I0oPIZAC?OLQPyOpQ>yrY0@#=1fkP27k}q87g{)|
z&oWNrcwigL$;MD3fiD)X%~I>1>pSctgjL=ssjOFv2+vDOQ3v9P#pbcaIza2SkURv)
zSB8d0VfFnVYBk~DoCyxlo^;#&aWFMAMFO6T$^;As<zs0gUX|A&ULPzpoP~Bn1R)&W
z)2o5IWM7(IIp$D6;X!ub=$o@G0!ox+bjYb3axtppS>zh&&jGePOiWCJxPYW_s1u~&
zTuwq8*hkG0L=I`e2K08s&#NpEZOoyFCvb5{>nPHL_B=q8*m7Oo=-5hT>c)M1;rTxP
z%~-5?$Ld=Xxraa867i3%cZVFlNO{CW@6nlY<eC&;I26-qRAjzb4>5vF26&8DNk(|^
zK%H6->gE?{y=$;5fWi8#!CyKaD}n1Tj9@}t&?|mY5T}ka+s@2rSZOXO48kNL>EQv@
zi0)-Z1IdhwqeJ5AZ0D^On>{=4M><~<3J48j@-l56HhZ2G*)O#sP_9YH82rLPwOc=5
zY&${h^#wcghqcXsKQWDH<ZPs&)5HX+F+!=xg_Y*O73=OYSr)&3Yz|rOTY!ItqP}k+
zP)p!eu=i^M^MY_^(>_sACRzjPdEK^(7}0z(OP$_+CYi{bb`pz#S~Uc_&&n@fVS!ok
zu@MTlyRvuog;{?$$fpox>sKxnIfW@c-)RTBNu<sTEG(?Nqv&8zw5j9kVSy56N4R#*
zfXB7Gmy2lY;zS86uGB_R&rxO>oDp2J-K)QN1HE|-a)79QKIqP$)`nqJ==%Jp$=x1Y
z2gDWTb$3Sc6Ew2P9&cK9Q+-Xr(CgKzHs)obpMCWA{a<gO@TRb+vz@5NC^O&!ak;&R
zlx9%aLR8!K_OI-b#8K7`@BBdVJTw%1M%KGSm`6|xWAB+9!6dJ#0?+VCsdoKTl<*^=
zD!Z{;$irvDOF7W|S0r-NPJVKTguwnAn+9*R<6$*p)~S8i;ZeN(-$Tp<Hj|rqVS8-M
zV^l@WjwGUv9i^Yn3dTM9YON-v&Iv&54?*UGXD4!jo$oV5(3$TJ^vp%6PXzdZaAFYE
zDVS`t9_{ZKd+}Ksw23bl02jE7j07TNqktW4W&u^{`9HXJ1Ora|ZZozO@N(>T<6ik;
zhookBnJC)Q<m-KiuRcVQdiF4pM@du!ugmgIz~dABT%$1&B|bT{j|8nw>v@k{A2`|e
zh7-Y1R&i;XIP^dGV1K_i{0yFA>|W#X#Ci@HVhNZr?`c4T*T-N3Qi9L@?ctnogFPVx
z{uX{s0q}kk5qox|5)jf8Lqo&+=2w}Ym)nM2FU3E&`4|rKV=*J^m?t6}d0eGh+nj7Z
zZf@_LQQEGHcnV0Y!^0l<lJP3(nLHWIXwG$nFhED^teCXx&RbOloXb{{SADZ|o7^@v
zCrY)a`R9BL(I`nZ)74*B2|uSmc7S(l_x>&9HSh3jBXXiaer1pfI_13X-Ln+jiw3MA
zh@eC(#DMUaq%xvTRt;uA0*0=d21s#+x6G_<0m~Wv>2<pVzSU$AHU5v>Oso8)qSH$B
z1=Sf0z8;l1wF!XPlpm>qyysi!JiZyVgR^9N-KiAP@*`wGsLJzkP~}qHhq@h+Hk!pL
z(w_WM=$Q%<?Pp6hGd5i}`gg$c*WcyakL?MmGS4{_yC-HH@qgz~U#WobA4j5$Tb%*C
zL~Wq_?6?0lUKc$_kSZs0!=?Y5`8_Y*CmteeP93cQ2nJ8(YwNSxzpTcy<@kF@;y>Tf
z6hP2M`tJv7Aa%<EME1(+ao7Gk+Y~vChLi?9|2y_9YvzixpZ}XkIz?bsUU&Yccbcsf
zu-5+@0V#UVt3KClNB%2FlUg>5hS+8UPir4x1XgChnQuRD_wS7IIk$Ack!*+2D-W@e
z|IbzZwXM&Ii1(VH^8Bm6UJ+m&4{2HYn~lNWfbfrJVy!0P*)IO)_`(=)4ZGOSJG=DX
zWCQ!I08mHM6=GCu^1SI)Kt5~zzr;j0Kkx6UpHQ9KKj+bj!wl4=1JmXuj2X=Slk^F~
zvTy&w0-hg-`ON5-ITmNn<Q(h5aOeIXQ?aGnVHRKGLz(_l7}}*kNHftc&(n5HY^AII
zv5pFCC^~TGitoiAd`s%(CODh_Wc4#IfQ*%1)VuB9FM-61tV*{h04zm&o=E)J-2VRw
z!{hVIZiK0{#s0rA=uiVYRF3^M;{Vtwxr1GCQUAQ0=iGjAykhI0%u$2kNd<(mWre)(
z2(60lpF3!W@VtK<0;cmH{#Qf-l3p8>KLZg9%g+=d__x=2{_}x6O~B(WY7u8#{`on8
zNhm!FU4Ne$!?VHyi+p%(AYJzt%OowISCuQsrmg=UviK~O0dGH2#(?ZocMWi!bFhDo
z*U8WN#QAG3{BOEnYrg!~7j)d8N&iC;Q2I|8ragisU~l#vz^43j+u8pn@hkJQ^6GZi
zfu70uCxc%%Kflc5`yA;%nN%hVb9o5&yqQS!aw*^cV>6%MEaDUk+!;9dI&-Umbj=J-
z8UGJk(vAoaxfd91gZ&??4p?UdYx6J!Bt47s@M)#`KVMe@rv!Z_WCi1=+R{HkA7C%@
zfm<!S8BMnTG6(G=4B&YuAncNZ@mun}O0%h8ukdZZ1kWSdQ2hG>s(1%ks<HgdxLlk0
zv@2v_YGi732RVSP!<Z2=c)s8fp-2+)ZM=WROVmoWW(`dL`uOkrBDlWoqcQkYGeXf-
zcOZ@F+vCB<>i^b+nCI1e63|Wg`u`a8%({V#ff=vA0j`|)NHctY@AYdjfIlgy6rrWx
z{(DyE$7L_j;^*R)k%9kY=wH{A_`o!hFvz~?Uu+HNj)jcO{_nRa>7FgOlH_cH;a@`d
zf8ZEq3mo=MD17r*MuU`=|9V~f#b3&*{#fVo{{^F48j$N=X`4%$=X?6E9UkvJ(|Daf
zypd0z0Pq2q>tjQ*w+<qJV=uovn9mPH#MlL*c0Rv*s9c6nsdOUq&9_q7zoUPLSm}0d
z;j(9CD8sJav8P7@4Wsi@qAlY$tUzi6y)P{Q+~W4(YDxC`Vp_k}cAonIi1K4%^OKf9
zigU-nXVwREwOUmsU(JS-vVg=d6#8&?rT+^b0swTnlbNEhlcn0~uDcV8K-e+?B+!!u
zie2}cTCp^;6F<aJYAt_%ct-2`BFXTuv43oiq!cS=e^~X3r&k>o1aK0XG5|{2U1+FI
z_r277h9dwpEod}d&|CcGGUVSZ6R~-wpBrg*k0%Fi(PItm;_#1lDQWv8)RJS;_NM|`
z3a9cx<3;M(2dm}O`lHjh#*1Ab-bpC{AfqCkhR`AvSBTEp)Mm5Z!|m>*duF5Hq}U(t
zbIvRY3;T=xhnhwKyrSgVK-FS9-^s!yNmmkX#fM(m$r{ry#N4)qr}i@?L0Z8zlNE+t
zxL8;*%TAYET|gYNeRtG0?Y`t|z6)-Li+)8Vau|$8az1b0wiCwE`V;E7Hc@A*?Yc8A
z4jI3VL{0bFrE`7&Vo9kCp%!qSa-Phu&qz3&?uR-f>4MrE=A)dMp10>a$$YLwy-^e_
z;|_A9(>H?livqH#ZxvbE?yC^cNiEvhK)0j(M{#X!Z9=!(RFh@8+GD~`&EO8P5Oglf
zhN~_N;Ryg0^R=x5{QuvA=z#MPa5E{}hD!yqg08!903eD85I+p6TImWQsZhzaQk^Wq
zDe*#2vRwzw;FoF@>)u`NlHb<&-JX46$Mu&Cz?f7TNG`ols8&$5;1G#&C(Su!%23<6
zO;auKVS*RFt9z%XpTljOP;{|}GHEnnGwE}S=S+TjYc%QoNLK6PnXaBxoWL@o+OpMK
zIK@$3q;<98)!gOmm2<&CKfO-(M>{|55W~*?G(Wskj>ud7#&UQbX9B9qKUtuv&6QqK
zI@jSE@qOv;dq?x*^;*>J{n;2GYV;!+!ukO6F_pw-%xTp90v2Q_+IG9k@NhcB;<b~T
zh|17pJ<Z(FE_AaVi@=D$zi;UrqUw9QlYeo$S6-~&=0^i!1s8(Ubx;fnf9HHOHUU6}
zv7sASB|sglPZ1ry@lfJ9@B?7YMt_W$<?p<UvPStW|A&i2!#=|S!(qeG!n?0HZ{h%q
z?vLNy!6)zs#ewLTfum{sZw_Z0U5kYtuZ^D}+SS=Rl_c5c$iji+V|(4ClnDOuoLscg
zYfu528=*$K0TUu-XRq7#oS5q#k3ySy#_tJUl=Gd<(%ZFbak5hrm5y&1yDOV5DrJ`P
z@kMw)end@8GKt2=oux~tW=;NXtbT{~N3pdLc}ZRL<`AmRi-N0IHXlkic0jF~*$qqY
zVt>P6vbMEVu3`xjM`MfN=-1ODDXfH;qr92w8OJ0qy1}TSQjgmz?HPth_oREpe?f12
zDtz4MmL}w<!h1@fIHi5McRsMj=YAW<tlLPt6$Of~D1^d-&J9$-b%2hKdmpvr186#O
zA~Hn3&Suu7kIelA1o;>)vrMl=3jlKK=4!3;)A-$!iC57<-gDU!81YQnQ{956{Zt4!
zW}~UI*Hd}YiKCVo8BSZHOd?euad+gWN;KmEh+<<TMIC^~R~IEe`rINF*#6Foa5M*b
zV2}%FJfqd%)d@iX0iC1fvq;c*wnP+nCO)P7ykl-=bc^@Z?or!QLR%NeTY!A+QbYi}
zWEi;!7Ljdboq?>!P)US34?-;co*u3M`$Ti3z2ES^rbYxg5pW%J_uxf~$&j9I9=EO0
zw9aPTVz&ym3=Bfn_N2bCG{I~D3f|uT&cWxp3Pl#iE>SBVRzD*!FMM=9D)=y_ShUPq
zvypP4l3VwndVDxO=)UEP(2UQZF7B?5tX5eiuftULI+S+}GS}vRCpx6>`(ddhDa&>*
zVY|DIC642OI=)3%^19@5cUDZ^^~en089;bt#DY<Om1tI<1L!XCGNM6{=D|{18>kF4
z2c)wFfcxx}xCF{YP5U1}8gLUGp`F`xc7L>hGK2~M<(_xr$kV=l-F@8;a}6MGOdX4L
z?i$B{q>@zl033KzWC8;NgL<4t-r{w^ZX1*v%(i*++b(Gz1|GS8?Ifu&M=nhZDtCQz
zvs2b|$ZnhKJAvm$JdGL$dmj>`Ka$Kf33W97#XSC!Lc<sr{&esgbr`$ZFzssV!=?7f
zcaA>jM@ouWf1X-61s?_a9TJ{eN*|m1T<OH~J_`SB077It!de>;e!5><`@{Vmh*qTl
zYt<cJJ|c*Y-5!ODsa~%q=(=+mmp7W4jWYW1Jv9E;FBMJK<#&*KrF_M%+Y49e^yX2#
zoxU%*bF9wces{OV2MhP#A8#+b$?l!=<;VrMKa25scJn?G$dL+V;)Go8{nT%&weOR^
zUCXzx*}G%8=#mJl^}F4>wODl^<BxU-JeyU1Q)7IVKUZVasMdN@Vuogs)i4%fp?fXO
z=Wf&16>7##iC+BxIAWl*LGOFBk*L+`(*U?fL!WT4V?{wlV(3~Mr{y@IgZI2`{Z}6V
z7VS2wN~#L@6LjLcU)g6Qm0&P^x-n!fB6QJswdjq8nco6s^&t3^!GX%SOn@0qBB7y?
zbbJ86zm^=p!hW?Pr#J+DD$8KaqzEbmOpzIwtPR{*v01<9Rcu)67}CK6!xO1(*B}lk
z4gPSsJK4VH;5Sfam=NSgNLAM%Wz8~x*K?PNKren`C=gbrI*jmFyp8qiYH{70;yUEK
zF3Cpq%FiBKM(^$%6!N{L1xhmu62iu8G-}wlQ~}N<IEz<r`p%$JNSR^QI7hfrZ`EiP
zB}^i*$2crzt8z8ZiKm-wy%+*MKc`<v)E`siOR(SiTvr&5YILusC8c4`xoziQmAB<i
zG{C6lIwxth3aF1rj4GgnG@upDX<+d9N^NMLtHqafo!`hexvp=s-Q-J^`tsNBT*>a$
z7*3^xCS4W@eZQ?zYdtB!kJ>J~F+AY%mkb#)T&a-LI(}!)<V&Z*u;e3WO$NC;iBp`b
zGRvy-ZxZ!Cy4Un3!`#=cho*N4Jw3X9j(w_5e$cVD)#Z}jdc0P|NNf}X7YZ~wJf@B#
z=BN!|QxDt0$;4f+z?3CveCIT@XImm*)_GgjvsAHjGTRgM$_W<SH^v*zeTc!R(?tfu
zgK2^&cE6copWNdJr2|2Z1A58edInu1DDCmLRtV6Nf<+PG;+b{%oE&+&?eQsLHWzv+
zG3KK9kx*a^=NwZ+{QxAGEmS>)+cw-9sj6cYGF(X-Z8z|ZS_u3dC^vR9a(DkR`<W?f
zck<OOCxSt}j1z_3(c4fR6GW5=R9<q81R6a~ei*Yg(w0a;dknyqlST2JU0v~l-fnBK
zQ9tlVNf{S{E0CA<M_;MMagLAUCmHCJ8F0+5tpCgs+w^0^q;<MlaE>DP+J2es07PW;
zzvfcoh^X`>k=G&PNJ)t6upVK!bgvc}>c|+iY6@m+5j>ktML*oj4c^XGl>m7`tuG}x
z_Ln85h!oCA35xRHHAK~@VLO{JFJ_y}>koZu63A^I!cYHTt?M=JCQ<nt3Xbnua*^}(
zK-p`YAdYKUD^_nkehl*L+UStoZ?Lu2@!B)w%~Sa3nC{jo?=08Rt6e&-XnXIh!s|9W
zh+1-(sm20RI8Caw+UgWWg5`OHTGa7~#k+5+&0X%7g>0A3zqaZ(Nv15OWL<FR{hrXf
zsC6A7g>?|txM?+$OEJ0^GYryjfwwRoH~D08LX>w)TUD<pBt<EoE&w9~l54gXZ3QsL
zANIbNv*ucDek~v!5G5|-Oy17#d=mKm@8;=jk8O)r`8Ce%un=KJ#^GyTSUqqVYf>2t
z55JBBnHy;?2p;7U%@o}3eS2<M?f=Rs>0ej?6sw+aR1p)OMXv;9v<YUp2OA3$GqdTa
zb)NM^0}~|h9RE3m%bKxn=OCUhdtqzeTDPD>dtND2nS6wYhyU&e<8bgZD{xj6E;H&5
z*(q?PXYd=Zvl*5{X{RYdn5cn4=ECjxBT!J-W$S~%#>O_ncUiT1&kKbIUjkL5djt0v
zo+%`J<<46rx7~@t@><L3hsU$6F_ftUSA>ct(EKyfSHhp^|7&Ze6O)@P5!2t_zj`|^
zO+^9o1(YmnJ9gUDKDxAB_T@8R6WW*R5plm9h@sMC=PRiBMnirIU5#w3xt0TqwVh+z
zFx_36;$l^@*7moStJNfDSn<L&P)oAfPqE*=iXyPGI=Y=>J-}lkpOvjnx3!#^Rkar%
zL%6xgcY;`(nf51(i4Uo%wFKBR=no)LBc78#TG!Y4-ehr?CgnlSzpK<45^#~Q>Du-(
zs*e05P^E!JjGGOYs6_7Q|GL+{bz<q77~Nlz`F+Q!<YA#JyQ3+=amO<`cOq8f{DA#%
zr~7&I@KLXROQxL5TFv@0+_IM?fzdGG7)2Z(Q2lRp*3+XP1e&h^uoyEO43{7Rv>AMs
zXQ!z3xIgKGzi$65>ks!Lfkj`BXIvOWbYukhSKu}!+B7bN!FKaDoQPxi($RD<4y!d@
z1KWV!@a60dTrc`@NIVz;U0>!<LR7oPA_i+32sYD%T6-B$bL6{L;Smu@qHVFej}bA^
zNl^Q{KVgZD!!^M{yWfx+h~FgrF|2gd{;Kl=nGPR7`XQ;_X#y25hST_`_rqZz8+;{Z
zC#yZwZ?aIrDLj_JUHg2BJm>xk<%DZZ?nh<O(U{eUJnXp?U_0>T^-xzH?0Myjig?N~
zNGTf9{%_d~DwfYd<Dz=B*|f<0Dfdvbz<7~&lI<)n*(*JBe2|tyf<F>Ow}U3LoYh?q
zr^KEyWNl&b=}y4<><sTHo2fp1|NSO@4xA8xG5xEoYYSJ%{VRUSz2r->#sbmUO=7`K
zG{NiTKm^psiVK1_W#4BLxpQ>A4T){%a$?fSe(KjReftPb97Uqg5cc;s9nxlPTxIFY
z;PcX$Z__NNW^r?m%-BBvn$72b7_O9y&RTNVgR;evzwz2Vi(h5Cbw*S^06SN8JwO8O
zOuO4Kta_8Kpfj@J5J==W-EVPQ1TWF5QDDpj@dJUXZZBgqG8!6}4Wjo1HsUtK^|R?`
z-Y%U;|CgIWyT)RjlAz1zkMTm`H)LmyKp-^i*9waJOh<jQp;TcY3cEXd@e0Usdl4Ic
zWJ{jvfo)E#ds&DaLSaNuJlrXK&lSNAj-_A^9T%B<RyWo)$a;}#F)?cwOlxK)CD<yO
z>JSxVA%YPKw-K9<#uEj1x;4gv|9O=pDi@STG5t~}XsT4({60sKQh~eT6$mo>72Xs~
zDMOqS#2y3>wpQm4L8T-+>jskNo+gxnUe&KP+!{zaVQ}|l8)n|+^4O9IUs<_2YEs`i
zc1~c75Yw3KRBhZoZs|vi;pG*4k>@Uup0=ZrRq;27(W<vu0S&K>nnpz)K4~XiVcefI
z0dai+BwRD@r9D=B*^=UHSiD+2x!{Oj!@S=g8u?_GQ#g}o{Y`C`<#$@LFER?Jdt0+>
zDSU14ZELOPKkWR@8J}`xIA7rxJD+WKyuEzT1pIG6T}gUA9?O+e($uEb$u5T$Ye_6O
zQ#x%_M%$rBLD6C9qKfNnq}nlrC*rQ_07LCt`IE+WubUy1Y2oa>?;p*qysCw7`b}+j
z@6eH_Q|y}^c^U4ph$f~>G>uzpf<2k_TYcU!Ck2B^84F-sSfjgK+Sv{5WaH^4H+=R#
z0$W+l%gct;cHD{b!LTbM8cHGvLRZK+X3N#@oEpC}nAbr4ih|~s2hz3IOcn4{0xCK`
zfm~R%Oo!KWBv}<=mh=aRvWTvzbg+PUTd1QIoCAjDoQ?LSYa>yD@3#!CySlnY-l8jq
zH6cpT3XMawAxxpzYH$nT+uG2WV@DE5MN<VvSkHG3^I-}5r0V`91crd?=eYJ-iWz<}
zM3@|hT(xi7W^(}^86BM)HMehU44nTx+**XMZ&*ILIzMt~X-OWZx2<ce7>2UUbdS4N
zCiHu`_?g-6Vrg;u!ClSm`F>teRGeyn%;TWXVYE=XfK-$Jy%MOCh{N3ae%^TUc%X>y
zc8vUB{-pZyvF2kR`h96^$W;nw?e4^6YEYQVdB0()W{Va^B7I)T7RJu9e8yfM#@1dv
z8pA}3m~{j(n~We|4f`+-iu@=)&2)ya?gnV}MvJc~-_7Rsz2n1G2ec#k%!g!Tds^kJ
zbIx*BTCmn~2R9zQQJX3_NY||of(C0)F`f}c(H?rzfr#G*4TWn1qok14!Ems*`jzNK
zTBq6E&QL>caP;*SBn>`mDB$Ab<KIQ_C?FGRE{gj&o!Ix9$moAAHGMJ^l7bQ28w|p5
zZy#Sx2C<6L8CMdwZZ;S1AB4lG7bv`32?k{&dVFo`-%sNyh69yj2;Wy|HisAmHT}{w
zZ~g$zF3&PC{0dqgH%IEOq<A|>y0$w)&p&_o`MJLfiK@>e7A4GCgK`q8DXm(5lT$QV
zQ22)IxPQ9IY*@QwQC_%o&h=B!lkP?zIU7Ix@=}tJGJYDbqfX)Pyy;*5Pb$eSL~-<#
zr5_?lUm~Oy5Nl+;gFm?2vVW-B(r;mPiu<{E5@pQA{#XPwM472x_G5L`T5a6z{;Vnt
zM)lHD?s}85PwU=uYHFn;tO0+z!BvLnSE$54Ex_k~SRzNxpNA6pb@D4~CTZ{Cbs<ON
z_QzalOZMGT$F-3`OGq9m_w3pUt@q;mxye!Dg@q)A=|H>$NuuoJoV!G{c*#osMKNc#
zKZkCkgWRn1`p;bqHOroF;$CBgYvbZ5GTP0$nD?aAS+?_aMwJMs@5%SK8jbtVs~bt$
z+FptUfANYUWb0&1{WS8WSz5dVuNukc8wlskFs}?Y4s}>*g_40?5Z5VPED0?ZBhRMk
zEnO87Dk>*3vmG}`n~-C{7F2t!?!`mq0P_<*ZaFZrDxA@9$Z)gy_uSdFGz2~l%D19~
z|D>a|nFgKtS+0=zPE1UkqQ{*ykp)-%mO*IzI;Xn&#Tw&h(f98^SLWpotIcca%Okz!
zZ}%1qioqT-%j{;s%_x}bxHuo&=83<#L{uppQkW!pJIb~frFbAzUaZsvZp`i1J(Z9D
zU`oMAC37reCF57|E^KQIPsVB~pU?6zl~+r^Jx{Gnqf9(3vA|Q3f3k2|#Af@5iAs&$
zzrrdPc_~>nJ#1?P`A9Sn0ZHG0hm4Wdl&u3hYJf-q{e_9+i@AFM-KgCfYm2ASf4MQJ
zuVKkys+N#i{{`N%kQ6lhib@B}8e}S!p>|_8lFN_0@mtV+DYx!mZl_D0hu$^vp8iBq
z_9O<$&8gpi%NLoPb&65JJ4e-iCEa257`#&CaC!c*8u92+u<d&q{zBtp<%RXip7(xx
z8{bCKuLTeNsH7Exmj*OI)JG%ZU1DN}$CGC`ElixjEq;sGg+({`7#;`*YJhOlh~MI$
zHoNS6JKhP}=r*AU*|$r|p*3Kw+owR09vbvqtjA+eBcvEQS?f!QN_=m}dPG8Fd3!kg
zodXXa-%KY4^oEzzl-0@WZk`8e*?8pb7oWX}LSv!ePBo9~LT<Z-8K0Vt`cx%9dR*ob
zbd6?*4pDBXcV!p6-P`ahAJcEn{Wv9-B-}Qb%qGL``)Oz~?f32Xof^^tSpW=Y=1wXW
zoa3W7i~l<Mxd=fisuyKL%w_q58@=oLR(s9$*houoE-!-^14X^HNy>U{+=0ovAyF;D
zR}M@01D(<C(A*xVv1aG@-gFzf)xx@^m-)C#kjs7%LPScTUEqh^xt4qfl>TI{V$0Fk
zTC1I~@>aD?A92^C*wTseCr~AJsvr%Uy<8HjXp$sb)}k7;!0+LLXXVWo7KeHCG}UrZ
zF>s!~-v-{p@tPW0D`uwt6K@{xk#7!_rTwqq2<?fz@2y5g2b0-Nqv>yd_`5y+sM+Dz
z87_<+RIMnG%Mi#S^M3kO$Os=_@1nZlUr_fb<nUhK_n~%XwRdgn2r}hgbJrIkcgJlt
zlzfAXQCi&7#c%y#iN@>bqBU7CGsx`HzKClL!SXTsGFh-9-cO4|!nzOR_iD_ai^n8z
zWGX^vlv;bR=|F<m#$X&9`<Ee#x`uc7sEa_4BDM{@2uk}HCE8C{Q5Mjr05W{2abKhn
zB>1Iy3}x7te)HAtubbB5HpO^}UJEvsipd(sPC#AZ;rzG!VC<VHO_{)N0Tc{X!8<Ym
zP9LM`*UCWiLq;zb2<X*HELv40o=$5)LdPrCb16(@{F=vQu)Uxvn=1qd<Cg}B%(~%A
z95kMcXw66aDghXrj?oAjRCa9-ZYv);tEIl4iVYw_S@fD`XqARBXfvXTq0U(rZ0g5y
z?5&lp;2vC0LsJoQ8;mdB8Y%}NA|iClx-?8-Z%(B9kUJt7H1KA9;S`4Dh(tw2Pdx-S
z*Vv-@9C!8<<NXEK+>RER)`JBUMGT>en}s+h!(BYt@L`vIT-QAp2q{80k_NkRbo4&n
zj=86j`BzVclWU!vcMWQ{KAU@+C`RUT<iCT?wp>mo6xZCf?pKKE=L?GI`S<MuxB7~I
zMSrCK4Q-<Te6D<xAkQE%fK2>w3Fo>uD~<X-h!ki088W)ND_5c2HpHX7$=oc_D4sgt
z-?^e9sCi5Qk|As3?##<gz+E<buyMq&TRb$lM@5qHmNfT#QrXX<AM~;Ylks0ik=x8@
z%DWKfcw2L--)sujT5riwDGY1N?oMNQo0%QAWiHIJ@2x2HL_9f6_R()AqA|qRLu1uv
z->CdBVlo|bP641@j;qan->~!&MO}FNk-{eFxSv3;ak13KP@#i?s4kzU<gC-C(&m0c
z+UXTTgtL6ngys2G*#V#XWzBe=bh+`<zFM$!KG$un`uXFjX)=#@@a@%}@oD59g-q+l
zU_1^iBP=ftack~AJ|;Hyt9I7qY@kJAlfiI5b}-akNC^D4Yb5Z%OG7Z~4rl_&&+wxk
zk09k8ufTUK{T-1mL`m7ML6F31=+4^Eb-daY1|yLnm3a7cHyFVjHZzyV?{0T?0y|SZ
zGd{PcD7_36wK_*&&0?;;xngS6IatGZocK9^eha;r(uSv9gQW|Hg&6CI9q;uS1<#}D
zi*}bMJK`D;xE4+e<4eC{h7Y$5*Br(QH;1}rm5e2^b@{9V{g{uK34*u8QnZ6K^U;Qu
z?Ob32;u#G|P@LbX5f+I_AWP}{Db}XuBj``nB9)K(0-yMC&R$5kjeu2@5q#6+V`3K*
z?_-sTg`(eiYkrZ^@7y9s0o%UMT9tl=ia9dWC4L#Dh?;zI>e2WDvsxEo9$<t(*Y0a4
zA{#sVFD$@kkXO%J_MuD=C8g`)8z}Y~%F}1@nEE}L*Y%qNOOk+J>gMo^X+WcQAMZ%3
zA7dw7x0gk8$K1l0Jq7soSo6L8XG>ay{fkTY5=dC@?s{L?K9~ggJs3r>n+@f<+#F4G
zNE5~JJ?SE&di8%D0*vgVq^K%!Sd^H`A$H!q&9v&KV~Fk_`}PkbbFSSmr7k-h$ax&f
zd5n$J_I|m%?lS2Q{H`ubdTGMWAN-##v)$|-RoZ+nVuTz(UYm@X;n!NVw&k;7341;X
zKJ>>9WE;p{Izx-vg-Azo`1;2u^6^^Voj2GlrG@n5U2h{4!xA@>Fyt0AbHCS-z0HmV
z^WrL8`;lFY{V4S(i`OsfL}pZ1c2~E~deexm`T$gjyvAazmLU%`=s4sHPqM1JZzbK;
zEq~~GUlz$P`O!RmzJ+C&0ubj88He>S>5>l!!&3!{Vlr{5OK$VFd6F_cI_99h1teHF
zlFsGPDM8fDq^G2}8Y4D#RsPJ<Al}tHSZRd$;7$<LCzuYnemGy=O2JC(FM)8|5+Ef;
zHd>W%$8$RT!_`=fOjw6wy($ir)?0q}Lr!WqzHaalGl(cR0YeYeZLkmWJD2Z8h<!_R
z5B{u-7H7+-w0{o%(y0{G#%A}<ay$p?NL{>73t}|T6clctj0BOvf9tk4HL@QPF^K^Q
zMz!Ki5Hop4^p#A(Ly=YC1EDoeQ}gH1j8^zSGGb!-c1C9;-)LTlD|-n^fJv4u<}0AY
z%Z(2ohn%zmpf)M=l}*T@NR)(TWYVy9lyEv9G`b^&8$SBLKAkiL%)5zkM~KGZ&9HuA
z{gOm`qHm&L#M;UDp^NR|7>4!5mFK4AA6?ogIXice!`<0iqtTRGKXGWQuYF^ywxE2Q
zPotE?<6`#jH<3HnS^hl`_uFf%gT>RJ$HxoAw3YknE4-6Kg@+omI-#`NZ>_2PYW&kI
zQ@fKCFGiX@e!W8P($>L9@Pw>#`5!WlB=L#kylFP}Df@uxFIp%_aDMkDtk&}e_o2os
z(#d2r^TWlS)!F6<P`FN-9p4Aw-r9L^xBtUwgdKxp+vDvWg<)BlVrfxA>x42z3%`z!
zkjL6M-L2n&(Zf3E0<C&cK_r;*Q-E9|Z;BHEU6zhqzukR6_4dLJ&h1)AdF?!sxBuck
zX`2(|3IpN%srG<Bjo(>nYb=dRKbk#WKG<KuE{W4~6IBMZT)`UhD?^Z<XzKD-Wq=9q
z!`A`gClU3p21aHE?!RY%UZrwu2wIm(v&jH9M=#jzga9#T)ovYT<yW=@3FceFPPma&
z-rpcWkR)IP(2C`}ZnMib^rBpvIcVpuePB%ta}BMC+(8mRS0*C}IXCqRc@J-p#(3hQ
zpxXUARQA}15Ee8&?7xqOY6<i6QZ5C1lxR&8E&?93u?;j><A<|IO<$j^1&za@3~P~V
z=sH05P9ff;gSZFXwZWHXB^B(;*a2glB`o0rsO)?4lHOE^z<H6Mzr~#o7iv=ye4u*P
zZP#ik^-sBfB*ykU=5*%#)<1RX5f=6`&4;q2bJ@)4)PCA4Rt&?8aMl>7sDI4KRJyVN
zuraN-?sa*x=>_;BDSHV5p7G3LA9MxWwSaVj7f2@>T7(N#Rs@oHd_xnMlgp`5wycw3
z^|r>o=hCe$O{MOvXmR?dcjn79Fbe7kAowACABuTOGgw@eeh(D3@)CnFCYxugIeoRD
zgd!(B$jHd!KRlgB<j@b^Y3+0i^Vj-sv2?Or4bN6v{mDynJ6b3kw!C*aJtE_)_pgt%
zT`GZHDp&rRTBv$(5;}Krz~}q)=<)!y%JaK7$a8zoIKe`}^z-s!sMfd3>EOmHKJp$j
z>rX~ozAaE%kCaca=rcdsSvs2DJCC%7qom+9y7uRiYenSt4w3CB`O-TE^P2N!U3)F3
zn5cvqhaJbh;}d*OrW|Q3M>s;P)A(d>Lfkkts2`rwz;vYrRv`XntezqW*^Qt*1!#Te
za_?1gXJ`hnz`U8fe4u)Ey~b{~h7wi`o+<!}cr^3eE5tCECORe~aLZ^tt233xo5g`Z
zYX_%3f=nISmn<XJ+O80cX+#PiN)d)b&EXX2czYEh0s=BT906inNrUqiv3Rlj(c)@y
z3KuhX#o@W;i|UFBR<ZXlIcAJX(AN+0+7zRJzNpMMLlEL<=9W)IT#6$<6^j-uqseXm
zNNf<hsWp7iopib8oZNn>O82={jkjKuR&7G#Xk&2q6%C@F_|;fmU*NPsZ?yrE92P)b
z<j4yq5oxkmBz5+2Uq~Uo+a&3o#@$R<4*eqP07yKa_hrd0+%%px5HD*ELG~}x`1lzQ
z9C>y&jF%o^RoXssT<l-ed}!kmWzw!!b9ngBD{!`dW=MRoOIW)%Gm!HHoPOXkUVOK~
zq^fr{h5SoQ*1JF@&8@Li2Tiy6Le7-gE5j*~v0UuUsFdI1r;jVt!2$g-)YYTBj0XX}
zcX9N-W)EjaV6vGu{kyA&Tw+xQ2LDBYcPWBC>t8rBDW=JNJjPPh(wjXm`dR~t*?n^6
zTs;RFmy4$>DwAt0at{T)kS}Ldn28=cazej`f@4I5iPYFSis9NNDpz%vrLBOPz-EII
z=B9Ky+XJod?YR*apzY3Z8Y_)J18%Dn=t(}#BdPis%Li%QAD;B(>Yt3Rc!y!oix9@L
zgSw~hjip2Ou$Lo(8Y*)yHu%)|=K{6CnTR;NaL6b`h6rNs-c8h4DzA7&1Er#B0=~?}
z#O88|<U-~AWO&PPSm;-SMsvCOCiim9l3r)n^K^c9xp2gay?xeBXR)t4zp_JaR^K>5
z*j($QOe!604h&Nrx5#nH4)ZCNr$-35DqC0HkZ21zwv2uf(2+*QqkkPof8S#HCSl?D
z*r8+d)MobKRb4X?PGu@SvyMizVr6cdVwrY(%DeQ}EH1w{nc|;D@8YZ54}MK02kBfl
zE^1vfn~o6_Q29S)Ew$bDCp}&r-TXmC@IQDEBja~hEEjs1tW;KKgLXpLC@XA}Qf`1I
zFix*?3$V+tTSRp7B01g0WW3`y@@br9pnBXEZR%pqUqXlmhjX<<EviWgKLz~nTvM1+
zh07<vmKPTNzpWm2-%aj6gwh9}JFbo)y9b7l-#?LI5!yK8H7e%@&KF*bsp4uBrJmwp
zjFW8?qqO~bg`qMLDZ8gqAVMxn`V>i5yv5<m<v&Zm!E}{F?@Ih*s+>t>qpT~A&sNKH
zI8L)L)rp{`?E@k+TtQ~+W=ynS(c&KUN}G0_IEC-S<TRh(HRP~(_FWKJ?s9+^naU3-
zDtI9c@j^SMynw*Yi5yFg>Xvvq*6$A;Q7Av7mM9+sh16N#X-r-j8X00yP$*<Ab?$!-
z4km8n0>P9_1Y!tT)Oj1dla$2#1|x1(Op1tPfMqcBUW28b+?ae1`}nEb3230AGE_r2
zUJe}cCJ5R0l?uHfW)&wpUV7h<T~c6&Ff5KIPinRY94Yz}esCXLI0E#Y96PpcrF+AP
z_ydOrfttVgN^868T(3YoRKA@o&^uNe=++M+gq^X&^z2wSN)JJUpXuyhb2<f1J$>()
zPI@H5G4PsQBFIoD9A92GI1?WRPAaAZ1pxpix3>KcI0MnHH$<1Qjv==9$3q{$noVw{
zGoQW%c`<$te9Px?oC$r?sn|YS_+t6%r{^P?%F~|{Ub-SKpQd`2L3DcgK*Av5tf3~w
z(`pD$kibB1M2h5Np-P^g1mbXRSml(&(}VP0ep?Zp;NJEFPx|DQH36M$BWmN_iC58r
zX9Y3F_nZWlF%HM3tNkg+7UG^w-Te7T-5+8e)8L|MpK*)3>vz7V8#L9m8o<e=>9Vx>
z3x#ZE^a7onUc*?`Eb)TK!#lAh#*C7WYfEZhv8iQRBFP1dvZ(YXb|5x`(M_56O1b!`
zUFk<{E}%m?)BXhI{3tRml;y*M;~ab@?X3LtLn<8-^n*W!r^{n~vHB_=N4LmFs_G1V
zs6Pof^i+@X8+RuY^;fIXkq>f}{fO`cmSyo=+Z_@XJjqt4mvU@X>LUd#VJ0m4alv*B
zH9lJILQ2Y>b}WT5v-XO4r1iAZw)Mq51+#<k!U_PHMPH5+Yy37XY_+&$mzsIRgzY`_
zx5m<cVfArNwMY~YihPHYT^ZQMC_}rRsr;0TL`kH|BwGAw0BGs5>D=EvI<mjT4SWEQ
z99Q7b;7V1y3A{!o3$?`xcQuI~%r(0amq<ql{JO7`sJUJrHryTJb+;`7%DZ<ca3Bey
z=Mysq#}#EAb??XxMnnr;hfGL;F26L8E_3_Ji=Vr5wZ#U4nj>Q{)IQN*587_V&>*^!
zZIG^zzaD^{pOD~_P$m%`IPIk>NPw6&eP>jA1=rc<UYcnP!GKJCG8r|7JJAD?qTx}y
zOx93_BGDl_BCJi@%T?fQ#MD>9A{=LU{I4of5J33RD9fhPuytZxEKMqfO30|FxcX7q
zLKS`Cf)g0xsW&(cU9B)*3V+ukq*LFFo6YEo918Un4R}bl<zfscv5D2-O(VwPOTzSn
z2ra(AxLFybXGTnGWyHC)=}Q$KkErR>oJHz3(rq1F6=>BPo&rbLw6H*<3E|s$rYs>v
zl94Vj>p~OIVy%|OcBsgLdiHmqgq?G)S(PI2sfb5)lG)Ho$SIG!U{Xu95gqRk)0D(T
zDMn&%r<Hg_wQ0=a>?D}80hz8H94+iqBZ>GlR|rfkwAkqzjzrw4TE}I{8ko500&%S0
z1n~K9vyjc4rO1)al@IeeF({Y$NTqS7#lAzoF3Cbnw<$!ls#l62rvgsvX2AUP7$u$V
zT+ywy+CSsFJ<9NE9$(XHwutd^NB=c!sf@}YiU3riV$d@h3qoIx9iN3dlq(;p7OU?~
zoMg+*B9=k%Z~77dkbk05tg**1Aq-A1=lpy1-edBJYW-4*8NnAbD)a3V^s$|?!3bCG
zE+(t>iWV|HcMdzUn6pN`Hp6Vz;?7H>!yn{d4V9>t_K0SRaW7G(iUHHYx0S?D=>tMd
zT1aXyGk>s|rBjAsZK}xnO&W#|!QgqRL$ELfGD_y#^jl=XW#kdciUO&|S>fwc^27L&
zEq~sK(4_=vL1V#M8U=8K2wz~$9I6exS$smloDh>K2?sLDK6Dh2=-h0f@|%^tkIA3y
z#FW<Er*++t6p%f(l)I5MX&z^23HFP+B40p0fEevi%I0Aoy2#9p>F1Xe2R+GIf7<ln
z^Bw?=kyH{rw<N{*QiL+hYkrcFUuLfe_h=z0UPhh<D=&f5D(IAmFV0FFk2>K$b3*Gy
z;(jiDiK<;Dc^yEJjG_g~L*)zrbcAb`CxSqDR-HY7{!89cp|3XCLZzzDd&9?Nw@6Ll
zRi{IV%ZEZ?|5?U5d~L2v-gqSXtSfcK>BN-Qc>kh_Tbs}`+1!6&0f+OqRwu7RN_7e;
zgtT6bH}Md(mVdINb4tAXO{$zLm;Kxg;m&JgQCJiaw<!$K%G2XdYhHfc;33+V%AQs|
z^kjYM^>N8=o|@Bu2m7h6P?_d?<Fdn2m8k8(T!qY0)Q)|tliT)~?yb=Z+z8pkhoh*&
z{Lqb|?@?;0LjH;qDL&|YmVS>L=CC$|%U_&f!(#49kNvyBJ#V7O$7g@PS&&9{f$Zf%
zWKPe{roSb6ZFeDckt%p!p91*lLV){DI=!rF;o6zk>zr~c!Lwx8-VBul?bGjf%0P$V
z;=D95L0A(73io_thfDPadS;Vv->B6Lv~bRS+hf*eJI!Ayl_S7(;F~yVC!>&oNN*pS
zTR<BBw;$*qRS|Fy&CF<C627IOPVWJ#<vl|2A5}55M<b}f!&8v=gnFP?kntv0R!CAs
z%Nq7BX&!z%*!V>Ox(i5Zy}6KN_~;8372NR#X%N1@oX=Gu1&zBuqJg8ZtpO_J!NjgF
zC+ZHyK*)BkrnfZ09q}hD=#yroPTqs>0X8U({qYCw%H?tzl{fF1Kww~C5Er-}X;VIq
z<i3Px36!_8vhrzwnmp)5B68dvb|hE4ZEq5RAbFJ2<}h74zgijKI>Sy4ss=Lr;P23S
zyWWXXd>Z($QwaQ`0c~L8GEL{quI?Dg2B|ps=g}7X>m<0W=99IL%n|G25-6)1n}(UQ
zpWhOr%`s_n1_cEnJqhZ$wIiNLCon2XfesvF*p?k17kItwZ<Iz-xO64z{j6H?>t+n!
z36t_jW{ePL>r>$uSp~6o=7=rg^tI$xVJsAfB{Boeai-|d)Pj-X&FyxI`34`}b~~L%
ztf7x-t;XjTDPa0_&_@49XI$DM&0jV#8(UlE_=U3RoQkf+0!8)&@;`%*2~=NKOZdLa
z7@wevy-@7-DxE!!KP;Vk-|^5}pmk-4Ow{szHY`ys<&unwz}#nNlzc9qnkr-bzTz^O
zrywow%Cf{>eU$s|j{M%ael+#%CTIc&W+s0q?xINGOTThSPH24ba3NA5DgJ!w`;#{k
z0i9kolfR2D&KU-^o8xFkG)q2VOe<Y>x?3+j2AWYUxuJv1PT+)8le&KN({yBO)U=EA
z^&ac{Uc_rQLpCF;fabf`K|s)jWB!RCwVw!3e07;AR&~^$2c$U6ZA6F$?X=`-1l7!s
z@c<-_hl6y&{W=})IMJlaWC5NOCY{iE$2{rIlbe=?uEzv9r4L`HqF%e+4$ls)qOk@{
z*LhtDLKfDWLj%2h)Pmi#lv$DK^?6rs)Dx;`HsB5MOmkw>T-snwWsMp}S?IcxZ$rFi
zzpRjF9_t<ncLagpt~ZD(1@S;g+&HYg4JlLk*|O`ga2mM1qe#P*P$gEoEFI9N9cR{F
zTC#KgRl+vK1x2}SXG}r?=OpcMkX#rZL*6U#&?GVopQ87SUxDVr_kv3N>sW`x;nmQN
zWwk(I{>Qzc1SXEh0gy9<1B&t^K&byNQXB>a_Tg>9>bHA#Wa=aK1T-Dt`=7V0Xhxk`
zXKQz{>$OhEIp_k%_N_O)C9M)e0gfM_7B#GD0QQBeg*L|kixH~}^r>}stz0#_?!o;e
z1b*rQN|Eo(N2G;DjGBg0jc0~{K$1UWa+LutHkBl)oZ~1OgolH(nCM^e@)OZ_wVPK$
z*%}@HapTNod-|H~r0L28sI@0m!H@=XKc!vKD_<@QCNbr^`BuxJ1iOx>Zi&^*fWuHo
zE8gzS;%i+h6$qtsD(SPN6=fqnx>YyqCJ7$ds`p?i7D-X%4k(J$?s6+U1V@bY;TteR
zH_49UlLd{F&Bl`GTgR1KeLR0*-MrFCYt2^OU)fEJ1)72@llJQ}tE|SGa}6PX!calg
z=5oq&s6=rL6;R{^`uzW)=`8%3dLOsHjgpY=4k>AnQevnG5(3glj0WijsnH!DsUayy
zcQ=ggR!X|NJD=n4d42x{IA`a+uXtZ?uOv8Q+A=_Oc)x9JBtDJ1TL4L4{EPRin;YI@
z^=^5O3pWwb_h%t)=No4oSCU!OH&_K<r+*eM8V5S;9iO>(t=1F9NEAe(9jS#xr~ST5
zmY_V@rTSL+sT^#RBp@3|gbrPd1ESNKY@yA<yr>{t^uN}#m6);LpGmXoBr2S;Ej3Rz
zFEvlIZ7J-ZGq8L^H@GFoK|8o~BIW>TWvTD743cXLuxJ)(D1!J&v446Yu|B+iANn!S
zr^n>ERoAb6CzzM%eUOLDM=%>CG_LCU*fhtcJnMJe=Nvh+7}Z@RPs1tl6vKcwuJ;)b
z+<yNUbFaCcRE%*{A~zrrER)i093yU~+mnysME96KWDdAVpF?nI0E<2s5WFHpSlrS{
z4kgI|3+LsiZi6ExOVg*c*O2++d2-fLISVF21xT#(IlG%ec1#75OYz4mBWv5m<_3mB
zEnlcFwj<O6NH_x7MC)3{fSqn>KeUGO+jGfVg|}*BYbVd}7h1hN1Cr^Vvr+X>2us^P
zL*Ouni;|g9r1l|@<dJj&rGmOLDkh({#29uH@jaBy7l}?guy!>8+ud*55FH$2QK_pi
zfb862?xx1Jm&WcONKHt*&P9@E>cK8o43&jrdYMp1eNuk@1aua9@lCx6(wAzo7Tq|X
z^OQ1#Xd;qmN@$d0YO&pWsNc6Dd_B*%4JG2_w_YguTpcYLSXj=>G)z<4llC$P+^5vp
za$F9T>?*K%$@;gK$=4kYINUt|&Jp@b%0{Bw{q+fl&*aA)tv+nkXE3DV9xXO88w_dx
z-+c10L{rG)Y*E^hZ;q-AZvWZ~EZCEt-b4;Ine+Xa&%w<OmCfBf3eEgklarwB6AHh{
z#2O9y%lfC3my_j1l}X=ptH?Mt)-(>(M)_{eDrH6px&uY@zs-|BJ|19zy~3OVde_Fq
z)l-U;8@^If3w2rZt?94TJFh?%wCR&@t)HYkedhC*B)*iWJ{^uH{yD35=r?JR%*{w_
zB`(Bc#hvakUAgr-{4#gh9Wr+^{O#fLkIb#t<C~EhvU4C`du#b{rz7B#uMvYixm%Yp
zoqJ`rJ!bIq*Tes`IUpmW?M558bW!5`$i&#K9uK&9O`fqs3ba4CLI`|+dGM6zHhprT
zd_{Wq?gtg&3f>RSA0k);Dcxt^C(S_&)@-<{NK_1ag}_xJu|c4afi+3ZNi2h|qu>fO
zkAyrw^S2B9oV==d95eHp0C8jLC#TTA+XT%}PX7qjH5@j?+mS!#k%h3}le3zP3V==c
zTm|$6D6&li(xY8wE`f(M`HF-YwPSU@!3lzs-Su9O_5}vt<TMDurp~S1A%jgXhcHI4
zf)jp|WJYwLSp>GD5Zf&_&laDXr-nqCDzMt9`O%>8n-09t+Q={U?EUFpUd{>db<9FQ
zyW2-kPiuHbVw_w~3^2r2d(-k38+_5je#EJZvddPCjpO<z-E~u@bT-zV5Y~!51i=C~
zmmjt!CiZ}PT5}acojJ`=y#lfk0-%chdQ@JSupo<d@3Li>%q>N@J#bRBZ(82VY9`|Q
zgF?vCxYz6yDH@w_SgOR96-x(W*(IW-wIzlkMII0pSlvXiBmXUkG@r>Zpq{B1NFHHN
zuch`ZH$s^}NvK0&)BFzYIs!1MrfhI_3okvNJ=pB$vSAb^LKdt)c7`CVPr|?@XNh-y
z#fAQYJOUlpzDU0+@hjT2YRd=3E*W}+HPhhp*kL3t3ff;x<A|{vcn7?_^VRM}MPodZ
za?<BKfjgRSVm>-`Cm1yr)7mjLJ9+#re|N(^1=M`)Wcgz?*5~}<{=GSuZsAMyqVU@~
z%V`y>wz(|nBj0=v4$05in+#un7YB{c8D5inQP_KEhm*8*78{xKB^t7LMk{Y{8@{BO
z*APsn{JEKJRy5m3@%3WBOVHOL5fVTfJ^!o7$4*B=JujN3mD+blQiwq>m-D5)n<dS|
z6&{93#-C(WR_Dv#?0njdVgD(4%Ov(rEEs_t%34v>@?jF*uPg&|#TTFv!ESs_FW!UR
zG9|Jz-ZO7qDQxt47d49gQ3Za=T&f5S##d&CGQ?E}$#}-HJgNj;Rz-qbkFp|q@!06~
z&{=;?x28$%ZH-FUcTjpu*rm4Wh)A``aH_S!tLDx+r{`)m<X2QvIlh>wyVs{Sy6k2e
z2sZ;!$IIWE5sQD)OQ?8~D3apf3feBKV{NZJ&dVFcFXF)<hlZu;Y7jxXU?L^4WV|Me
z9h`~t7SLw`C(y07tkS0iXs|ern6Y>Qs7Dcgu_u1Dd@BM!F+@o5Sgu>W?_PFMIEOW*
zUwry#DqzTaXn4~>Jt8v1$d2R*f3?OyM6H0wNdzhYfLIU^%Hy_qED>Pg^Lx^uEMk#z
zvXQ^@(r4fWS+KE7K3->&ha|g$+QgJ}8DTNXJ$<a~CKzGRJ5V`WU`0azUDx~myY9Ci
zH<?3857($!$b%z-KAx+yc+ScC{%QfrhOhQT9+UbK-C{j4tLbV<w59y<$@J)bcOwP~
zWd>LdfE3=a=di%Co3)=Sl9bWc)f}b^i;}j!n%%=>0zV54>}U7b?7&s5Kb3mH9}GVt
zFS~ip0epc>Yk=6UHCgXnyC>l;ej-o?BE=FoVx~`&PJ{`>^Kr`Z&Mos#S&ltX6v_79
zkJ`Rq8{dBm(J+p5#8lv=^=KqzktBVBhZA`+{#u2X1K<y;Bs3_+bJldf^KW7jNUk5G
z(4VsZF&e=-m2!b&o<EH=(WcbTKdMXf(W3dz_EhQzkNyL7UOL+02~%CO5$ZMHp8v7?
zt+wD97>?QCG+p{_rCUXg$UWl*^nT^k#aYA!x9Uvl;L(^y$i7)l-Np!Hy!JD$n;T0#
zP0R|oMx7GlHF9E+eon9=Ews5)`WHU<C*EVtd$e7qo@;K{cAmTUO7&P9G@RiJl8Z@Q
zP1$BY3=}H~KmDp8Vk!7i*7|k6xkjV8?K9fxVxfVgcA?9pzN^+KSm#8C&RgsRjf>*X
zyT8=*?hRvXpFYuw<^yhWc3F}F0ll-27RE!%hAJ2J)JIj%>FG!x#fyizpt;K%N*gzX
zD(QF*ZeM0~awWS`DYZ_8b=b_^f5j=UY;rGY-mrULHa9-}{8~7Br{4K21FP>R5Y^pY
zypu0dU%S2aSOB<M_YFYnDEsTDFMF51s?1i^V_e-w(<|9B&pjpGw|R$k&eIDuifr#=
z`<9-AvL<o{x35=F3OC`mW}SIO-4RuPPB$99HQPw$41Rxy5kpNvgu$cHi+gYpc*cJ?
z*YJ)YqnIqt`!+IpJ>zwa&y82j)F<kn7gdX6(RPw95uq3Lmfg-6vc85BIdW-oWYob{
zW3h&tZbpEAI}emNKir{N!^S~4tGoX9$@4HzqU`;ykvNimK>YXDb1q@9csNTt2?TRj
z3@Yv106BNQF$@drW$fktb<}PDcBxV}G7zH)7JY{SaS{_!ABcrJA1_O_=f+{sCt~)s
z^tfX}18q!<?0^m%UsWe{)fy;{Zs7HrxRkX`-T$<JJ0#>3*2I>wHDJ=Gg>5zT17|?C
z4@v_IQ2s9QaIU&WOD5_&!*EONq`q#o*p@6@p)kRdtn0B9i?{53yxeXUjg5yVOeX_%
zc;`TGSDc`*uZ0J`0iYWY93BA3b}hx9?3uKdZa$c(2q3yh_9?MP=^bIq|IzSoq>7!)
zx*dh>gnHDe7ish?gm2NP>Ua*zAvH0_cy?m6q^3&sILb-5$%iT;h3irIlzy@SXgM`F
z49=O3Rxf*kJJ#z_rW}95w7HNh>XeH#-51B1jLeGe7}n}|(<O?^G{rpNH)Dc3n)arS
z;cq@3PI(5<V1@RWOtg5qoviZZ-^@V`CJZ057%kc|T@W$|@*#uf^49hLs3)#(?yx6;
zN6W9VMiz6WPA6wi`7Ef)arhgXY6bu6<VTH#6Im|xuagGd9KY2Tjjj+RkN?^u<NPuG
z4@pACW`fjWD&QS~Min`dZvO%=H`D^%HCsl##Q7WQ*t^sL!QHIlI?{Tt3{S_u;u~tU
zQZnjCe4nE_SlF*;>&{_uhge?ux%^A|It}4y?D>vN3kFp|SPNhDS*fQgK4u5sdbOjL
zd^^)_k(}duYMXh79qh~-v6_2jQ;hcR4JGVuc8Cu+MNwh|`s6y9EA5?2OM2YjyPR}*
zcyOmr8!Ua;o_2{ie;C-AtMm&0eDI_$<wiQ5Vi)O9WFCDK>G=iiY-=)T?T&_}u80(8
zFTX4)m_zaQ97r_E0T432ABzoVTf;}$PmiXDgQ*-b5P9)mAyjVTG<cdMIxB9H*6LA<
zJXAM!e?6fzZ(M{d4dasCr+lb?detSpayZNYYT~;~3vGqaehkG2LtXa@P;f!o7B;W$
z#iJ+7P4SNEpK>2@r}Q2VA)k=T?d46p8jJUu-mmWzyVnnqicM`#pC!wDmG<AIGRteA
zWGzuYP$m&F!x+1p1091`gK+Gfpb<SGWW0X4scb>LOsd87aIPy2QgP%pn3k6ak4i`Z
zM;GJ@#otkp>wUfH=tXg&>U>nwivXx?xN#Aj6mD%mfsl^^Bm!g&nR+ZhoJS}Fl9>r2
zF}=oK62f+ioJc;2Mz}e-;mliw)kS6jH&85}4J1*(biic39~Ol9%hVAY7nd}SbO;wp
zg`V6W+bsrvgV5Ryw<Jn>b{N49O^0gmu1IWXeFn|)DlA?dGk|s#s49FwxZ3fZ?;}o8
z;W_%cdAhfZHl}aUerKVAIFq#urB!Gd!a=pocJ-D3X6lG>ShQ5cnn0Syl9k__|HDlt
zkCP-l!ZA5wSn<Edu_K0%e7dt&mD25OUuui#O?kOg$u>0>lV$7vW@tb@vVeiB$fB<<
zBe~UK{Tgmnne&e)T><4_Z99l)=Sf8`Ezy+QCeO?MdSsJ(e+4y{PPOd6+xSscuhT`7
z^ld&wPUHyZ$O<?cB8V!c?i~Cu393jeQlw%~$A%SNW3HU_B0uKL_eTY<pnNV=W6x6c
zl8qB;L9v!EFv)?Th=AjZSC#UEJ;YiixBE;XLr3oQKMqUA6=Fn+&(lb(I6NOaqA8v@
za&TpfLR~T}jx)E^uM>+K#SK1@aM?#-k@aP-N<$Jvok+#CbH0DO!g4|8wLvCw$Rd_T
z(qESX_i2tX@Gu~dk8{;6We0@BAV^NPc;sd)O*GQQJOaO95^=<lZAvJFX%UfEj~dix
z`ZLSzE$%APY@QW&;`kOSPzda9Xc}lPphv~C%h;-a6-NGN&MN(=nQQC0pp%uli|an9
zJJ+`5miD^RAnlC{@g_D4%RL62du0%<<wNAhwa1S%u_K1*RTg`_^1ti#Y4|W3rrpQ$
z^X^hGEpG<?4A5xJ8)g@M9W}T+|6A6!dkx;IcSuWYxvh>HWfZ<q?`=fs!E*ag2bZm_
zNKVy8(p_ix?dyE$l*^8sY^gZ2-SMI;^(#HAF5t+5MsJb{@&dU6BB0@{z-#{2se7VT
zpP3JE+)?ZeG$=R}?)T0ROw5PBD*53x=-Hzkyeg3G$!sv7ADtf40y6X#icCcE^Mfn?
z5afFJ%Ip{uLe3q#q#24jIU&R-5QqYuksrw!IzuHj#b0p4HKfU`tIyKtn(K7^A?SoT
z^|gx}?_1DY7V%AXH`<dC4E$$Sn6W|Z=q5&_7wEnquXu@xWkygH1pxsAiw2xY2I>l+
zQHKMc;|F8<9=Bset)ktD+b=__)^Lo`Ogjp{8~kH4$Xx<AeNRn}0jKqTlSsz_|F6-U
zL+?F6&tyE}i2Co4POG!XXa)|X_!_%QE-ri%=(((QY|a}!eZl-Ci)jM%y6YiQ&d_jD
zHs$3Xf7`E@x6-ibiO;a&d3lJ5Sb0Qw1W}kR^^OM`%D}@CK#N<!k=JtUPx<p}?wcPW
zib?i_ecH#a8*WGz<kfca*|(E~>6(+jN7WvCLJy5wb_bGc<2m!)&b|-aw_pG2E2i=(
z(Z*!(qyKW$+J3cZOr&V=%xz|>bU;%~R>|2*{{ll%IVwF{t?7trz){n~=H4<SIP#lb
zS(||NnP&0SR7;36n<96~;&F``mybb^ykx1&7s--UJau*ZC*gQOH+|C)guaYY>Te>w
z;QU3T!+`Jf!zT~0icqsc%ca}_$d!B3MeDrdDq(tzAUo36@Fm9Y#m(~eph2;bjiQb;
zl619hp@&yCJqkai^b?lbLWK_AZ2K*{zSM5;J6-U|u;tQu+u*qMIdNY!zK6Z(9L4m!
zS9tII;7;JFX>Av{%d1>^1*uglFz2;+tJU1uqy4eXtBh(aa1I!Go$$J9_jif;{c&mQ
z8y`M|8*fo12#!e-_mYJMB!BOyP~XHm8w@C+MTBq&?>lb~TpU|O3%G%e(>eon8<NSa
z``mUU6-GXqF3xd_VtnV(>kpBCcI_Y4{(vTr(K@+E2tg7mQ69F-#O#4!(JE+g@=b5#
zE>Ks>mRnV&HU*&<2zaBRQI=zGzYjYb3H0&j#}Lu0vrW@th5E{zn9-ulOqOZUb=dWh
zlA990)8zsEU;~xs{L9BV(c+M3pd)#0-hN;M@k-my{>mx)+)70@%{1zF+Q-`H$#;+i
zQZ|@aW*s_PpMMTAB1K=NqSltMr3654^~uckXv-I*sLlX)Gc9P8z#3bE*kZaleyoev
z*rMV3jmHw%-y0M>G5ULMURE&N(6ytZW9X6!;bzplq_2RF2_mMmBq*d5|4`V9!kN;{
zt3Lc;<P|q*`@@nN35NaRQF->wQL|=D^*5dUh&$O7@M|Ca*B<M!Lfp^W3Teyd>$PKr
zxiS8vQ<my@>kAv$7EQWU)7m{1ANp42d<7gCL7JYk^unl(t&CkqiSk-YJ1)jr;!d>X
z(;$maVm_L#3wK|G^4|_FhF@QjsXJ>eg#5UOzlz2KN<6oYpS<!{k%u+|`{jMt4hF6G
zJ0?@-mbZo*&K094SA(o6Wz#Kh44XGcQcE}FNekrjaC?ZoF4tA6w(NfW&Aw0OcG75n
zM9IXSzkoZ64#@1DC;vIyk=VUgvvb*=(dK$L_fm+igH6DVv7!&DAiw}&O#Wq<3AE9-
zbX!`V3~j+ph9h^;+GNL|>}LqLUUO?r6Q6u<MzjMptVats0@DI5mXM5WGtdJhOkwb%
zW|HsSYAre<B9)d5t>@c4%zL2$bvX(f+XkFD;oFyVY2U>k7Q+dmLJMO;#f@ZhdOpQW
zzCa;hMqW!wX9RqOU$|tT78{*t0eqR*s3xA5t-X;LLv3B1oGAN-ZY_IwMbDX{Mos=>
zly2sk{l`KE%RqdZO`6}2cvL?D-b{_hnOT)Er!AhvjKv}jo5eiN3yWnw@0<XsXfo0#
z*28X7$Q1b|SsO>S9lGRD;<!eae!VSWpGs!v%bJ}cnRmA$`xZ;6WiliF(&~+dWPe<t
zj)}S+YYD#Tf8`6kBJ}4fzqJCIfHH^vflcdf?OBRawe4<^(O!k19Ui~Lz)tkxIMV#B
zw6DgiCq(&{$g=Brv*?f4mi{M9jO=krZ!i$9yHk2sQ+rt$RL%sg3%U{9)VEf3sv(-y
zro#}77Y6mI`-gHaG(vYaXC7Pkcp56f$nOI>FJ#MFeR7V@HmHn54YQ0j(UHs?jfNXW
z4a`zJJi7JDRc6DDjHCa6)LK!>KTg(Sh8Xq#6N#4OU2()#;4>!PLWR=w0+5Oy;-M72
z*Tc06oQX!m5Q+AWTy(p!$_%+)0APos$C6Y8OnCC&9RLRylJPh$h}c=&E?pt?<Ck6>
z&v97eqhs{Es`Fg;@iN{?xt`%)T&sIy(uZHgybb_HgYbkUI`%J@7ct;HZ6wl%QNoM(
zw(eS(3`*ttydftkud2y}$>%*R1msBeS?R}zc|>W!N9B{%bi%y4UdJhB(JcVGNHGO`
zTCZ2W%~~jg4A(5x)n*e=(W`R+m{V1#_s2Bhp`pAIz6dG;bRJq6VPqGwtMY4|LNfoV
zo3e7O`_9|9Zv&sk0H|dk#h;cCCLLjv&-V7^C!HM$el1kv$`tYB_it10#;5qq0T%LI
z7Gu2$W#tw}@xK6@Ma|jS*_G%~Ri4t<{s{5&G!$FBhnlTZ?}E>H1g+h)k}(r`mzwXd
z<>wwYUan}muZ}KVY@@hY{TaAYG|0g-XdUk*Vi}+AZ7xtilh2<GP5#$2s#wHiYQ3+K
zcwOyO6#ZEHvFcX%Ur)njW^au&FNRLN@RjAoohIE*hk@kYj=s3@uy7$Nkntjgqn>eZ
zYR!jb$t5W}u$9!atPo)a^a=6pD-AHx&vXN*Rjl&<_e0mv2f{*YC?S0aKdjC^BohY;
zVKLHWE`LuzM@!3HtcoZxyazQ$Dsf)=Ng3bE<$q%i@p8wFtYdS&4qlZXy^h|9HYZ4W
zUFl6xRBT8)y8s&0wSH_EBH;a{Mcq8uF%0U+_I-NH;y(X_{+#mJ*kCl?eXw-!P9U}6
zB17ib`}gmkfd-9AfF4x;XvL{ov6jld(x5J6ZRf{5dmg}%z{12NkkRn>oMsYD&-)nn
z;aqVSTSP|Un%n$eqtf^GwM3uR`|rjNHfhDErP-)nFX!;$NMV_P>0xAqG$)HA2*8OW
z<&f;h1gN};Vew1FveJVr(Fx1zV9!oL2#PAgxDk~e`TD1!0AEEnDvQSI@qepm=DeLs
z5ljj^SASv5_;INB_YVmSR<1S<ARf9TEs^F3jTS*!x@K{$FA|7s90~yrgPoUVQUmE}
ze@V3HGjwV#Y*~<q(~DNpiPmgNA<IJCwAa|j*9sY}Sl*3gsmU65u8-?!uX@ftt5dPt
z1S@<><KH;|lKLz69s`LCQB$ADbC+79@tZzy0!8)=1z$yqNi;-B>M?sH-y}Kr>8HvK
z{3EJXU%nSnS2;kQGa{-ToXA@bB9}OS8w}SODBXq=Xz3w76pQG}=Y#6~4j^0NW#Ip5
z0l(YlR&|1sDdA}UNG)}s50UI*Z+79I6}`#bW}<O3yAeUYtegy>*FSgN#LwCx6|M(5
zRY6qTT-Bp%C*&~lq;Ktk0%YY>Qo%SBL+LAkQb>wD0W$&=yfyNw0Fkip4Yd5#UFae{
zU3@?cuQw{R*U6CEC`ZUvl+y&&el1B}+&>_oTL6{(EwcO$^6-3<EMtM3BLTu~^s{}G
zavF6mXb<*}>jfRQAt^!qUWa-QDpjCW_zu^7Wy6AoPN_?R;5_y;vhRHG+bpjkhmss)
zN1(jx_|M7~u8xch6N+Ky<PY#~BZ;7dfyqG>YRT1oA>g^;UfL4Wtnbjm-{8V|Q3dtJ
z=YRBKB-m@M-+14LqR`e^-b{2i+V6ay{q~%0qv_?;cu;E4#o_sEp?Y2^0?J$PA%VvM
z(O9HWl>50ojaaRy#Botizn6bK&iAp&#XO;>aI86m)@m~2mqgHS%gLhlv!gy9)lX>C
zb{0sd8sOB6!SAChAd@jl$pti(d!i{y0P+Lohu*wMV_8&u<con0!FVMo+R-<hx@#}Y
za%^Pxx6b!N<n0LXm<a>EnK`j8{8_F|hCuYYw{W3|0vH#C{ILr9d$8`TKelVR&%<qx
zQP(vitKHRhs{W%A^$^b*@!AORui-Y3w`7eRMV!xKqOJPh0wj8k$ddBR`%6K3Rb5>7
z5qzp4f_--oL;IBLV{`}RIDx89<dIl5VgiX8mt++NOJBJO3JeVWGn?Uc8n!u_!K16D
zY~j9WP17gNw_)}F;fkpMO@}56#ftb)wZ5eyHcoUbCSi>81N0R_1@=t<0QSJyd<+!m
zaddIS6s)gx`SK5ED&Acmbo_R-Q}aWUBB4nP=@0ps+HGrb4#Xz-;v`VmKq+7n_;b~O
zFycvVwVPQH4!=G^*tllF%P8lkxDw~b^N)gsnwsVBrR6o%UWaTbW-vF+-bU_SWO&NN
z)X?R>LX&6T5Be|oV~}`wDl3xJbMY-8jyr*~Vve3v{|c8*9@<Us<%OEgRlm|5G}y6e
zopCi;%J|PN=2RH_oc8FtnHF=Wh-k<5&#&X1ud|g2n<I!^(aGHH9ohv{5qs80Hi0mi
z7apgJ5dHG3E~bbgTkzOvdSy1Y96zQQEgnXde6Z-pbxBT`(Q|Oo!HITPj$aH(xom$@
zmLaX7l*$xe%o<8~Dg=_XNYa%gR;Eb_;=&Pv#oJVn8y8@&v2%(Td+6Sg7z^9J9Ku-N
zK-Y5ArJT6{ClLrs6f%vX*ZqgM|K(r|WzVwfm_tWLr#utK5yRm-!+nFROzKne?;`IB
zmQhcS`iC_<R)h#UzU;y7c^0bUb;ICIuRE*P%~Km(g+zr8K!JoMj4u?dpG<ws(c$%B
zv;5=uMvxHhwyD8;1$AqP0@SH@8VBA1>y?Oz57~Ly*lc}2%;C2r{9!w$B;_9$MOwk*
z<4VhJc#QE7wpHHq6`rr-^U1f~z1-eUoiVp(({#@387+=a2e*&%!+3j{Jew^C>lG@}
zhh>@14ZL!009PhTr)GHb)>h|!b63Mt;Ss}i8|g+@AY1$D>r`fRFdk)QPfd~K<4}Q4
zt-GJxdVjHt>WAIG2~{;N3yvoQxWaf>*GHu`xwLm~Pi9#&WH;@%2N&*l<}Rn_mTMon
z&}KNIF=>GMFIs5ls{iS?lABIAB$L-B`&{43XWCH`OSI^S&t@%q;4SN=3ZNZSio~P}
z?=$2&#Jei=upP2pAtov~`AVf*SsNZD0Pc|e63DAVnT%6QxjO6;<?+P0XEc%TH8(5?
zPX;Oim0LdAucgbF`v*D#nE9JknQRoPP1D(LR+A_vjm!=^KSR?jQG5!2yDhbPuQFk2
zz2rR*c!G%|!<UObzgq;r3jnE9mk?y!ampVfaK(r2r>T-_3~*4h29gExv~`hL0%QEn
zd~w*D(pq#w{)h-;ewP)2NR3hN;_V(8a#H^X0)YBs*}569^xdriU^as=uk$`-$FRgq
zoKD~Fp8H9@vf5PeE<g3=N|w~D$_t5m@4Nq?T9E3z6+<^sSb-81v!A=6dNH{xN_niH
zG@K%#y&<>olO{!CJP5$x0KMUyQzd2=?Kr<P)_Q$!#dN|_e$&A)GK{fMPdw{_s}Q``
zZo8SHs;oO5i*z*}8=T%E4uMWr2~Xh72pRF51Up<}?Ct3NJ70Vst8u~sz5IHK=<D?X
zD#B|riPUDR;`2@K3$D9u)%N4|xpvyhV~*SSk8WsH;-f(hD8g98)*wn~EdWpHXhxgC
zaBpW>Wor0#@ip5TCKNNe+WpH)?>95w2tO{$as`qvu@XdKMp_=@|E@`EVf05>zSE6?
zH2^KQX9n4?raV83x_CYaddT4Wu@v~UKysJdyGBq-+9#3wTj3Kh)*|pm9#rkn4*L|^
zJQI0EEF6zGt(^Xc2rfp|ip2rLm!9@#tD>N*sP4lw`o84x2onUVXh$N<(UGjoow;R|
zI4T`84oo?PXeUM|pCX$~&<pw&RBwAr2NZ-{kb6#Zlobj$M{LY`Vr5&mS0q^E9Vh9a
zyyiFhM_dMl4OM2_>ED?z&VDou_&jFjDpHn7b7&Mw|NW$Mbu$elN_DWwhNjQFJ*{TH
zOTWcr;^{Dsk;uYH=C|CsT*?;AnDG554|);L{g8QibSv$YjyH~HMYi*oWU}Gc?Py!J
zk?G6+wXM8>H@*`;0Eaz3-KBc9#(aqEFAy>_oM67B1JRL^kV3liI5kElKOySAN9#IB
zod&H$C}}&iV7T(Wc<~;t-wH#6qO4EqD{KG^8~!f?d_AD7>w2i}pe*jr>~jnaswBWu
z=SHNtSg@|KVApEpyPvE|uMr}%#0_>8zTG>4``CDS^Erh!eaQ6`{7Ub`yNvBLH=h-|
z7NlK8b=$_1skXpOW{POg&K5n7qSy;s%$Q?e5tiq?2t_T&tu)441W`L^%f&`!_XXOB
zR`{#1bb$`7+!=L=mb<Gl!_6w5?Q^2=5HYaSvhBh&ZaUDjPdbU0J3xOTdFWX_gPd3}
zEZ)16MKy^sBYT+uD<{{t_UV^r#6oU}Jn0`tj7(Av4NeU|9BfbhDl-MaVgl=>Hdb!7
zE1Ij_ng8B3wpajj3@MkV0~Z=La|Mba(YY}~7GuyY9^K!go|gq~Pkx0bCR{Z;GwQ=S
z)x?kKTsk!xO{L<$GgXMdBKds)G3`%yPK03j(d6qk^N4%g!{0#c;w#WTlgkjy8~ANg
zbblrG3uo4`z;)ra@XH0?p8|dD5}jJ*&-cbjB)id6km6+^gT1E4DbeJ4bx0D)eq@ts
z+xjUC&<KIMHmlaBp^fPR%4xOz5IP@=TXNX%wUbaEJa%{(os(p86&pDcNOJRN-gG+l
z)F2>oUjWi#BtM)-=<uuUxBF!+wjPsqTr68Juju%9`fLfd536x8ExiDbmflnjBuzH4
z0ZiQpE;+$exb75L)vTgv-muI!*+-d1XK_xw;?)#C8xru}Fl8t;cuTS^F99-~AtBd)
z<zsMIVQH(6Nqy^-v`Dw0DeY)Jj!~o$jvHxb==B0pmHfERkoNa1Tc1``w=9y<V>Sxx
zy8pJ&`PO&~m#9}hnR(QvaNY&6D=w_xj?%L`QaJ3~OBChuQq_mVySnu2h4(wWSKGy9
zzOyAjH9!2IBA*Of@&tnh07X6D{VQL0o$<TEplzx(ip~O1zg)(_6U_+33a}bu38J`S
zmIiTxVXz*GXJhW(Tx4$1K*F!D(zaD@e{Qn9v_m=Dn%8wT1%0O5h9P$z+{#PMm$O2-
zDS<foj%z$>cZ57M`wo>ljgA=<_4Wd?aUCx~>=53V!3Uud0Q?9&O#r>2<CWm6<L9o3
z;wm*MzB#QuT^s32BB{76pCO5$=2rVtq}i6+(>|AVEf6jBW0f7$Af;_B9A?G!Ca401
z0+r*J(s!`_{o^sK34WkiYi{DLyTD(SG1xqdyU2fbon`;szK^bJD=S0gb$PEqk)xCw
zsn*F_M5&QLxzg6l*XoxPhm6=t!_WwUN90}X?qw^!dSG7Y7MQDa{qH7i+|cxF$s;2?
zu>k0W*D6;ys;{58s~sQm7mhWS9b((&UFv1<M|i-z7Fz6**ZHzzsDwwZAv}83&^3Lk
zf|Ylj)yC7dHZ#WsEDAr224o8*y{^$}@i88OF0>X7R{XFhC}7aT8T_0=Ucq_V#;ZdP
z{t=88&~2gOH?b`j@F!R$3iJH57(8(vw0-IaEO8i&>&0-Vw|2eg?GT;U2Lg!kJt~P=
z@^))>FED3n=eG%A^T>;^1t7seF#xC$XKV`G2crOh0qIpQQ_%|af&jpv*RN-8%<-<o
zP7^(XKxDsj|1^j{Duo0|;T2K`dVB(XJrbKeLCaLs1^%oozL)!f3y=g=cO!KCN1#F1
zr6E1Ga2-{@!ADWfO!))z?@jrF;@gQmThU8$$$$GFXC#&1YOKPOn0y+#4odsu7XOI5
zCGiRyet6tFY9rCwWjK3NEBVVaYZ6AI_QCslXZjnfSMDaamivv6E31Pqh}`2Q!_yT`
z%B7P(txvn5FIUM_Dto<PY}6wRj4C~%7k65(m4$8Ym&C972THO={NS|zSlRnRLZag=
z44X*l0H&6#Fn_=j7C~KKJ6XZYYncgaoCX)Aq9o47{0L*rwds}}ydH=q*pF`)!B);2
zMb^&Hki^CUbuxAXNF)(lvz*A&P=FOA<N!8_klhp{b}CM*uX`(08A?uu(kD$0+r&dm
zZU6F9#~!)_Xw4A^QVY(pNkd9-9a7pVQk1%9Q(VfmDcrTjSt$CopbqK~_8&H;W7j7<
z#>^F8M7^3V^6&0+qSw0vpxeMqhnL3pZXr|+Ac5|s#cPk4o*9foBUCu#r4W;KO#vMv
zm3fy1Zk*_dK>mw22k0eEGrcZx`ePwSfjjfblhdCUQV#VED4PL6YhyHFVgK2x{B7VT
zl(D`ad}+0I_cL3?RqG>pr^Da2`|}Lchw}_3&vyi*GgeTz%33cQwGL=StGeZr3e@+6
z9Hl<2?}a^3Jt>k~RNKe50oDpO^M5U2H@oDU1;FhIbC`xsOP7JL>66gY(?`%IDsnJ*
z=P4rUA@UAX5V-w$t!=~|;|t_Xr@MmhhKE3bDKM?Z_IAI9c9&P+oM@g(%en)XOiS)K
zDu5T6+9zHdXlDHYfUlz@X}mKWL>gbuxB~*CUpxc2hrSkLeE}B_kF2Tiy}DEFbl|J@
z@PSkaElPf+*)L##2$G*g?8JjiTrfLs3PSBZ0A0N;r++~(jfkQD=s;vLlm%2<%BeiM
z1Yf*f4jP9nV4$Lg1}kf$4|GS6MTC)V8Qn|bV^urrQZ47U0W({MPT*QELrna3NEm=a
z$NWhYgE_SG%<6wyKoXeJk7+(M^w|mivDNwty}K3<0#D1}^4TU>Aa+f%ZmrJdl=?=V
z4DYGHDdbV3lym2N<;$q$Qgp_`*HCGV6b*&xV9T=Y89!g{-oHdk%*R_wDZiVwiI(hS
z1LMz=Y%+W;(#>_NBwhAH`OSv8bwS(afT7k5X+Ar}qvThk@?GF)8xjo~jkCfEx6;P^
zZ}EYeLn5V~2CN1wVX<6xexT@L?C|V*lZwAFE9Mmk1z?0QS@Jw1NEt7K0`2;M76zLs
zb;K~*Gp85D^8e)eB`WS`_~7}$DsHv>*v+A2rXDj_8+gr6J17VgYV|vxfpmnA4;&6|
zSFre<fcgD|^osr#-=%8hCFaaC4!`$Fpdn7D|J<ayD$*E0PUqX>kUi+}$xpH)=TxFL
zuNy}xIBWyOosdpl7TBZ$HP^pd<_>bf8bVVJ;zd33D^Sj4AkjYaXN<xCy&nV^H{F87
zHUlQqa}7>;H*<_l{qqjJG%6%}PP)L$GouIRELuMyGg-m$Ap>END)1^pgl0R*gy8)N
z==>HPwqt}yj^1quReV(j%MgkL_1He*95jPdKei0KN55$O03N%Zm((*2|Hk^8%8BGK
z+F){cL<UwQ28u+$L)EB65ipL2IEZ08+kW&O$l!<&8u5H5>0K@RSHhs=kDWx3bMMpV
zhXK63knXkf&L1AOmzUews6b<lkmWgD9IHEjx=qz4ms-gkHV_JUJ#usR=Hf~|;loi&
z+h;9eK*1^NW6JJKf2hA;-DquzFLb8J`UhapZTksEXufEUmYe~$6+u<RD0rUJ`n|jJ
z@zQ4m&)gv4xXt`OVL|?w?V71e3PPoXL@CRl0j(7+{C``AYdmxbVfa-q-Uk5(a^qKU
z*U4PP+kYamNuV^`W@Wx2m1_kSlT4pnZB!J}@^9D!-xu>()ZrKt{J8>H5L>10K+7Qw
zCZ?C82ICKuinG<h=r_e=WqB!)gt6GXX!vK*0mJ1JPLTzPT1V}UTKyF`l?jYH?MBON
zoN195k*vQ_bVbaD$lpD?xx0%y4@de79M6#aH+{@B4(4$=a~JDyL9U$~Poh%x`s3tV
zqB|j&FE^fJV-vmI{K*IJB;-YO)I%h|B`hdqlF#tb{r$)>Oi%qRLCuWLr{HH!5xr+^
zuaDnwgMZNal3aG6qGr~N8R9-RDPj2B=wSG2l|`5Q*aigLAk|Bh967c>KlQ#H{mFCL
zomr_TzId{<>u9SFU2iQxw9Zs(!;!I<G;z9EC4Z|`JKKp8L^adh6TE>dInC@<ULvP<
z;o?L3<X~Cz*VA?rF$c$bN@2Y5&ZwrszK0mZb$Cg}ROj%!KPBczdsyd+rdijWO_b8r
zQMXEv>!C-tmn^iLvgHhs#ue;)hu$hQ4o@8iFB(fI!AWdKT4MkPwmaz$%+jvupf<m<
zi80z4u6rnTV{YBV*zPL{Gfz&H#rA+JiOW0#u`u>P@7quE_NL1+=xNEPpPCk|G1k-n
z{#$5)cF2L~F{#3{2DSYB`)5!pdVy`UI%;rqq&zhP6{Z#`!;5wu{1}ijFY%EWoFpj0
z?dEu;Gnl^11ruA@nF}UGIYrxps-@GXIMKl^V1_(gmH4-jxN<ZqxJk-Oyfuz?Z0J0_
zN}2HjKAj{dWr^~FfYhg2jBUvJUzvj(Y3OCx!>Bs<Zz&Q7V^a$%_~Usb8eS?cQijvs
z<~Rq}LGhhAj4`vcJA!n|uI>JXmf<V*U6AZj<;@q8fw*^jtSy;wGPpf8p()(nyYOnP
z!r9MKHGlWUg&yMfMlb-Z<@Ae$cR@0=<8y8u=L;B4tLnCZ*Lv<A;`jAp*9#5L>r30c
zi|p{18kNc1;qyAyq5;99pI?sZ4HlnHNt<MXj=0MB?4rm}BCiBJ(}B4k&3VK#a+D65
zu`p9e5Y;7-Ya-^3&ezdZd@Z74wR$4nDX??07%)g@+)9dp84JMU`4$ap{Jo<}6lOeG
z=(K2c2kaw4cWGI;hcXa+40woF4o<N7i^XrDo)qQ`+#*Vmu(N*)VAmO_%C6w1dbDHO
zHOUAU4CU}U&@U<&L3eVuNppr)qjt4|J-8r+sr6}pJlZAL%fSVyNrpezr1WU3bHw!P
z1u|JsCpIpAL%+8Li(1B~zOGS&-ab8rg*~Pp{dmG++l^djL>$n__<ka(c@dp*zsn2^
zuA%(-o#@#G$j|HjaWc9gJ~HJNTr2@EZc&a+^Dtij0nj?!<mUI`h8YE_X}bwDxphgO
zGDLp77nGarUgz?Ov1Rv4`UifL`II^Zd<Nr+rBH4qvIz`PTpYKqZjBbdgpam;iAb#X
z`jX>1y8DQ(_xtuj`sFE%WCOQ(4zFKQ{cA$OlGJRP)v!)&qgR>u$3;T8-ani+YD7Dt
zORKvJS!-Y&1H^xb|6Ol7#K<!eVPF)P5sL|@p(Yv&KMMo=rN`<B^by#PGZJ{ikGbOc
zrRAH8Eg6wIFy=b!u`c<Krycgs$S@YTI#$7o=kF0DZCdf~A(d{<Mtm54ei`%cjmVOP
z*O1h+^S1H|9gmj<zI<lCFR$Nxr#0TL&3TQH^po1WFLovTZ+}b$Bm$p7L_}*^mHo0Q
z%eDU;1Jdn<jy4J#Tz#f-a&q7j7+D}<K9br9SYbhMz|;Gxi}k%x6gZF-JIZwWgWLV6
zj-Pu%-c0^7MDaeqbOIo#3ZFH(q?6p1;<(gV>r3aV_cC9*>=pTB=YC!KnSBExA%%BY
zP|qEv80$|rJb0d;<rS4Sgno%ww7EQt;>tePc4Sk8egj(@$y=2f_+ldUVLc&#OtE>s
zssR{9@l{|AGQ*w>`7LO5q~<#K?yyPedTQl0lJSc|O!>?DuPbi7xKx~P4H>(hqWM@G
zD-m$5`AcB!0y7r(O&YU2Dau^Sk)d@E1H^jGvkm~IRA8`PRm#`_X5GwmvPdn<nfqhL
zuj7$UfTH<-%cshvC*5hhhW^J<-7Wlvj?tdn^@>pbRc`QXFJva)5gZ>99Q>mq=)~WF
zrO^2!$ySmYT6YaKlyhY0I&wt`;?$mrogFcT|H>LAqowN!hltU1IorPhS1534nu(Wy
z@8$$<C^j<^W|MXt)}PFrJrxo&QD)$ipY2M9kwH7kB`vpoc`6ux<;MzC;2r@AR=HzB
zab{>)oyAP3N+F5vk{9itydfjmu5~&J=+>xH#N*<n9*!IHe$L%jA<aiZyzLxK1ErZr
z8{04z@QkhoH9+Y2!4DI)FYzY``kAA&5)9*JLDG2zJ8;2V1cvy-1@CqnA3GwW0D=So
zQmAm19{>1fK!Rx&q}dT~s3IkuFUbLW6CD{{@I7kXl68n*LudjL>LAb=*`H;w`=R;&
z#@;Yl!He39Qj0S2`+GH^<kO!+Wq8T4M2>u|OS<NsWA@Due3|QNO)m!V1n|Cj4V}#<
zfiW7lqo$BBagOjU0ei8>SPjbtkiK<rdB`paS=l5W3mWtd4azW157{O~Mk_E$pc3M9
zuVygpE-fGIHU(5b%T&2kKU4q_%3W~C2G@xN*UHOSU^pVdE336oT=1=;jDqGtYuVmd
zw=<UIU#V-wY?H1U)BOu!_dey8$DSDuTXFa8a(=T>Z)shlr<sR`q}NWHk-%PT>WuX4
zJrNYbn^VuTB8jbhK0=5lKEt=>(W|$213XqX5~jnb&zx}92Cx0`_)4Eg{s&jLJN`)h
zm%9TWtfA7E{K}!-NOG~y#mErTn2b~qE@*4~tCz%oscY@+=Hai-2e|Dm*A(Ui2x*wr
z0C0_gS9hKnJ~42J4${|+(aIyf(j`2^onl-04ma(e)~)CZ*q~=_f8V;86uUFu{2gt%
zn>gf%Du6#if_G3wN`n^g%)dxSkO~_3`|~kK6e>5npX6tiSyBHW$D<N3@q?hDszTh&
z!LkRG>KD5aJZ#3$m)>n=k1i$Vay(-1rcw)Ma?9k@ta1Tz7Ld@E_&QUaV;|rL&i39K
z&Dg@XL6)72V{Hg}_EZmA-ku-i1(=I}%lt&eywS$OqoDpDM#fmCVW;4EcT!-382ezI
zX*V|*P7_YD{NGhGkW7cHSLEZ+Z*L+8%zIvus|g?K#MI*>e;|v2RRR^xSW|05-JfDm
z7VhVqEI*HUACGCvYvEkI$2nB5ER-YvKt;{Jyed}X9O=&SM{}-^QsLGR1aW6lO6s#z
z0mFtrYOuAY|1F#NFcFoa_!x7J>AxZbEicm=`OHWH!w%${z^{f2T-tyQ*j%K?j{(+M
zP8%rebt-T{IdpHo^L5^B0s|o5o)pf{_R!r8e}e*wC3;Rofd!mRRY$mitLd`TS*-aG
zf<c3bwebaE0m#dpk7{)i<IZ2{UrgA36zLWn)+ebr_x|O>=77-B0$w37wZR4ibk!?5
zp=tf`nl`W9G&{{oe&>5wsTb+LtJ#~<%+BTNdVj!0LrS_*^-NxPdDidid}Y*#NxgK!
zn-C9H`N}iTLLrqk2GwfgBcGO6--_Moc#ToYzZVk<D@r+7u}M^k;T0=K>eWMFbH>sF
zFydv*weTVoGoJ}?^hry^myarWxfvagz9-#eMj_}kM15c_%^sk#)}w$hhw^Y#8ft(R
zuSq<&z5z@{u=Rq7YamkYtwHv4_!Y33tzA8+`0ftjbut=o0G^-tgmiekzd^e}V%bAQ
z4hex!tI?H@=RNR|M~#(Cl#E9wMulu?i8Va7{l45civ>k;n<%z=-E=M1YpICnAJqz=
z<GW9L7hu028lZY30Hb;NrFLJv4(Jb480{8fhY|m`4o?D;63qc0?jSp=IY}Q|3vjVT
z59%{xhn9l7z(nCM34niy7#-$k2W{TqY~9GynvQyYc}wOtxs`M<<^S?;X58*MUC~!@
znS%D^u&-jy;f2mLh4)e<uPnxvIZOg6YBlV|hxHmi4|pb>5OM!4KO?dHejCy|s+7<a
zSa67RkkhQLUQCma0g?jh!>?Wb0MyKndTA+*V#Lp(n3><Zzj*y5sEu!FHB?qH0=IzV
zp={w|e{bvGc7Bzn>&!t$MH~@mqLAw+(HI&9I+&hNTaj-w#i9exCh0!@-Fjso+VMvk
zuxbExa1u{3cz*T-4DlBt9JLi#@1MQ^4T5$vd~SCNcPqIlpy`$5lZ>p$AJWv3JRbHw
zRp_DA@tC(5a;PxUoFFIN>ut&Mt@0h-9kHU0AZ)5c>Sg?tc`aGl#fqG&>9{)7ZKCt%
z2<0Bi%TsiwlaVZ~51O93h0g#%Ox5dEn2Ixn<aXKkiw5fFKSTWSM9d;)2FV!Hj-yaR
z{ba|(E+=`$9WMtE?a>$?iRUCXy=xEKuOcx9;6u>i3o60#D2&ISO_z@)-gkJE<#^kQ
zX)ICE2TxlcK6k!L{+||L<63E<*{GncAP(U-A@p3=7xUEs`YHkrhjc8-x(#-J#1s70
zD?jU*${Drk)zOaA9C<XSAC}Q%z1rd5_BZBUY<pVT{yuk&ng}Ao+(T9FIx#d}Hm5fJ
zN!rwLT*Hr40GbP37?#)9sE6AB29~LmX;`pGJ!5H)2N!F*dIfnC9Y+C(4I61%1(Yln
zl?wYmqzJY<TKrm71P^yH4)%^#Jmz0WK-VY2Ul{R|rGRMB{=Rbt5)VFAXsnl6Zk2jS
zc25pWK4!x}MsQ$UDd%lNOwc1VK=)eJS@Ld7T_~R%HlR{aDaaT^LnOq*TpUC0*=esJ
zYAklWboAnZ%%YgpEvBPWz*VACx%oOa)ITT>&wa~qR5cy7{5v$#kVeYyCmt%`x60!l
zaqS^yIuo6aru>-Q&36nIPcXelRy{eT$2YKlhA}=D$up>mz{YZM-ciXnhIEZDkS$%m
zM`?~A<syvaYPGV?XkW!*L3<evf-#X-^F<K2Wn)w$;E}V=>to=Di!FV=*pu=qlc8nM
zV%zz}_m4og#z3#xedPmLw~L(t&_CD<$*9v)kC_uJ+zxRWEDKlSCh+p(&i|&WZb48e
zK=z=XC&g4_yR`H2D)N2lkz$hgJ{A1=R2*hVx6ySqzbjaXPf9?l!3syCOrL8;Q%fnP
z*GXGHnctMKs2JSBcALc0W#17f<MWS4z-Ji2%R)?Af$VeSh~%crf;;rI_@glwhrx`$
zg`&-KgL-&tBYW|2fWft%rNle1=C3Ud#mGSgwdx3_gLP_qB^@ZKHDhL!Rdv|)45SjC
z?CJ-z-cj9k0dX6@d1Fqmx!(2bXy7{&HkJxPIo0SZt2b_966j-K6IN#81^PasUDOnu
z4weQUn0;xynNW5EPcB=+W$||n?+qC;bu%rNS?TIhz2u{?UmU9Jmqlc~%kam4|6j-F
z&bx@!nOsGx6N!~{8DHb#<+Q7k`0JdG%5HbEg@s6!{n3avZaTuXzgXirE^FfHPf`Eb
z>Kf4yp&hTLU@boY(<?&~F*u0&m%Pi&8t=Y)wgSrwD*Z-5@c`#3$5Cscm)3Jg?Iz8^
zZg0CZ<GeSK=lm$$-~u=nD>gsGxf5RBUC}x3_c5rK=<9L4do3c@^W^&*f^=M&-|6DG
zrgZwW$NPtwwj}4R6kdUD=cmGPr}%Kqulcn!Zw!n_E-w);K%M;^+AP%Z?r@wPa49v#
zH0+(IOo4eZ3bdm(bD!vl2GI=D*X~48q8(W+Ze1U=W5tmMc>okufA4>S#NTwV<HGsx
zFwEGG=yW>5v{M*Q&MdSu@9WYJU5=PM+@GSo4mYs{!V36LFAzR!w;<!7?|86a%qVtm
zxfXQUZf~#|bu3<e)bp91-x{~1%Lp%UO?}MRQD|pWka>sbXo5%L`MK)e9aWr~chd(t
z=?2ic(a#OxDOzIKVgfL^q`KsF7FF)L%yaamv^DRoUpJ(a91^-N{-Gk*YteUA`&T&O
zAbB@wY4exXB>b!Rb5W@4`Wr(_ilkUftheiXm^V~=6gJUH=?;))oXu8Z2o(}J1Rv3$
zv>r#JS{-Z=cKiW;xZ53h6Ct1ULW8H#Chh*v{ZEOWDtL!~HwEypr^}Z1_Doj}O+6K0
znDZz0E@_g!Dqzcr-6Kgi1EDtpVO#zG>HU?sqxX|nxZbyA|NJ)DaXt$G0DS)OyC8_2
zeMP=Pl+h0k2LWHNXZW2*eeFw2OPux0=`NTce1!VF3knKKSS#Z%2V(ts5Ns9HeGTgT
z?ZLWwmcD<De2-NGkp<oc@7@ADXzv?ug)N2Ozxi@swdxuhQgafvC!H@^g1mo&L7@t;
zUJ${e<>y<`(eI+)&9RTyMOmFwK&?YLT2xsBRB-~F{KfR6;)Sn-MuahutBmiGer~08
z+Jp(p00t|mtvyJ&^z75|z4xG~ZNUtQ-zn_6<tPxdCn@7~R$wJP$tKz5(i^?E>1&kI
zPo3fe!$~!=a2W5>?*i4Ji35H4NTy0?L4?wxCP<%_H-J(H$J*a57}0;-80@C&yoH8E
zj340aJZ-mmt@$BpLZIbc%}L7BLB&A0IRa6)<gTZhr!WCftA0!3Zi{=Ij}3DczPD-u
zj#WBsuMPh3*XlO=IlNx7<3OFhwBOIwJ;?a5$ja_30Fx?N*tk-|s7W)X3qv=?S;i~u
zEWYdTCGLpHndjh5Lf(P;{^ij-YHDhQN(&S$p2up09GH)G^l9kZb>C_avO`!Fg+*W$
zp$2XmH=`UzgYuU?n;vM6#fW<jC7~bj^7Duj>WUY(W@>Hg!$5xqTZZV@iiYRTeI$+2
zWydivk3PZVok1iTK7ua(^LAW|+p3vI`5Q5MQM3M^*40D|@1M@p(?i{ed7`4|b!^0j
zERE;~l8Ic!qTjeHAbb{@qqk~1giO(n;J@`+!0lG*I^0-_ftzo@=?oQ~J=4^-bJd4M
z#wyIs7qfqf)Cs?icR*V<<)9Q2+?tF>Y&5HQ{oAkn`7Y!--tZ{w1^BX4xA}Ot#SNH>
zu&90dxWOBvB=Jx<VLn2-^XX22f%#bLA8da8-PgIw8btYP*MriSY2QL1q|a=^hxuc=
zl}2(eX;fqH%)@SPQad|s?ak?#F5z7Xi-nX>)gU407dV`pPA?W)`Q1lTKT2eL7Z4F4
zphtoCG7`?<Y9_BXy1_b@DT|-Oepn$ow4psB*nMbfgfiNQmxhO{os^&H;96dXIr_FR
zM{`d;7S|a|xcELHh#V^a7qh<75G&YnRTfU-PZ5yZ1qrnz4#rXae>9ziTNM4*#%Fiw
z?k)wEkVffP=~x=+Zk0w#Y60O<X{kjdlomt~=~}v5B?Tm<yXzg_>-zl%yEAjXbLO1;
z{@i@C-bo4O+WO3p-{?GiAwvKc%?@>Y`-SBgUz~W5_7EW;93CbfV#iuSn45|1mZIGJ
z4pKq&?W6Uw|6rBs#p7M>?PJ<YniDM&h;F>d+trcu%f<F~1#RnbxDvx9&mN7m8Q7d@
zHyM=MeIUC~O~<vT+>@U4vd6stLjmdJRJP%Jt0M_M(KuE#>6Ok5p>=$`KBA75%E5$Q
zM-@F&oIr;anE1pWQlBo?EUp-KeXO-DK23Fyh6#D}ehZ94JT_cdH*E2hPxY8LC>h7<
zly2>8I_U6^{@YkUd2-hMQ^Vgor^e$};m3l!8_u8BRJ7y5U?A+*)BzwbMf0VSRItV8
zyz`}KIhty^gNBecSqeboQ%(z$Kjt9oNqWOFA)b5<=1PJk$aO?iDN;ced*umPltU3<
z=*SeUyzu7;31bGZ93cYD;bs<x&@z2oxRHtd^?OJq;DvcWAT3weIVLs*57ta#ZGB3s
zx+ikc42Drw-Oym>uFUMR*zFMlBPg*-k?e;09uN~s!1-U)e-%^Qj6b4$FfssfE`-hd
zYo!TU8X=`<?tfSH>o0LEp8pk>@!upYE^<GH#D9l5Zklbr{sdLS?(I$^-DPQ_tr+QL
z3>*WE)&Ja8;|S}0&aYGb4ZpTzo^Ps!ojwx0l+q{=?0@$)P$iuNJ38ts9|a?baG^6!
zWF$1ud!N@Rcy9@E8hh^_7K5nsGKcH}uFL}7pjrgzw{v-URx1mS!}_Zv*eqri#w`C;
zlq-I-7R3JM`Kvy=9gY9Tu)4WioyjlhJ>gxIO3iHCxBNVIq+ID}+D1`8SxrMboHKd*
zyLIF1Lg?sxj=1z6bIRMPhCWI6U#*Qb8&kKfzMJQI%+mV_BsbOO(zU_m`=bpniw(WB
zGK9337Xr=0cI7`sN5Wke_T-CS=&Jvr%_ydB?GwdCKLM4<e69}qF&a$BcdpgFE5t#B
zN8$82mK5jDD6VFqLTr>a8X0^h0SZhs59PSqUOoC}by^VNqYI5p>B8z6OZNmn(2jnJ
z)3G5)mI-`u07xz*s1qUw@U^U{GvJXT0$$jVBx=(G*e1ertclpO@4Uhc!?yr7d3kvQ
zXNT9-QTB!#%Z#{n%T@?p0)USi5wor_ja;%&HHFj}a5?y0pL^ZoqEjnB%D#s?gVnpv
zP$q`t&84X5@EOSz7wr2Qgj!WTKuCVnLRqR&BX|MIsJMm+=Oukp8olw_M6Qsx>rqTX
zr4u=M{e<<SVcgP(zH^8~e#mGHlin}9Yq(B-9#emOaO>ArFUi+hm7kdA&FAH<k9;To
zXrn~P)6e>w#RXK$w1gVxBA248p_rRdMbbA5om?*v@a3Ka+D`7}xqS8H&Z)G~RSu_6
zJurKbZ*+~h8H+ApeGm=Wmv4V{5z?mcI9vU`39xi*J`vlw_G^~2UIaccx1xyztRy_*
zPj%YW*mz8Shxy-pu8&mszLq8QUrAQ}$a>Sq5vS&l3Glcd4g2ZUPsaj6j(5TIhJsq7
z_}x55!Ki1ej5pQKf7|g}HL2~)RzHe!o2Y3fz>+OvmHY7ZCMa|=Z7+<9GJLyrix*-<
zazp}4F)A~$ts!TWefiy_ZUC2gU)mlbs9HnA&hIK1ia~vS$Eo=ipAt?4C%1{tVPS(r
z|C;QEkO9w7ItUV1J|F>~NhOXQh{q?wKy~dS;7Z0gY*eFoLh3|9xX+R1JggOwM4+?O
z)k10i1k1s?DIjUUiv*xc=*b(>4*gDV1GvQTv(KnEC(@(n<hA_NfRuZ<*{qX5a>Wc_
zvl16<KQNoVg`bMk1><~m{nz^V(F}H75&w5W%0~$F!&hKftvA@I4g=2;SY&z8p4Vc1
z3G5f6BY#U#F6pL)VILRkN65spN=0r3p%>6tNa5T_Ri1#1pvjBFZd~*kENZuP)=m~c
zmx$k>uZk&E`}gN(>9BED-^o!tFC61QyiwyD-Jt1f9FiXPSWyUDVZx60`9-%ceGleN
zX;SN1Z#T&^mro&bm)|=8ozGA7X6i>US_?TB&eXX6(^eH*E`*eWJ13)zhMg2KODSa}
zeaVTa%JY+1aEq84zBu^CUaH|vu#K&qW%t}KGW7NZ7)No}@{bw5&?2swnHIIRrA&FU
zdhK-?e9CzFqWifStDFWo$>`<Fd6O@hG74KoEoC~+E#-o1@jufE=f}Fc_TK+y7yJ6*
z3;%N(iNH{sskPq=VI}`YkhphqC6xb>{=J?SHU7cVB7ZyG@~EX2K5%tASECHBM)P#q
zt$%>D=pR)<#!rH-^{Ppq7IYD=@v>RIbR4i&D;mi**n9|SDC*35Pc5hZPq0U=neK93
zSJ^$My8Lh9+=`rjl0UdCRpFn`QaqueO2R54t#usQkkBCa(?I9sZwW|QPo9hBNWm<&
zMRuh}p69}(9|CyXEGmSwcs1ma_iP`CfGv!(7d0$6F&_8}+G$mQ24pYlAzWO+b(<;>
zvw3h$uX)ZaiRpw!*e3AAc-yQ4ZO9)eN)!$#@()sy!QjxMdM`MCc%bNW@dJTQARbUh
z3FN+#>aONX!2yWeI6boQ7k^F$1M~UHPE2_OLIo?C6ql8m9sipJK!BZ(w}8>*WOp1R
zHeEg`=5l=DFK#ajndTkVkBP9qd2@R>myCgsmwGfnIZALTk(iDCR7UK=hZ%%{y*8&Q
z$HvNLznBp0rR0p3BQPmS$mL^^2^cjY1p7H=1T6-c&7FF@3_5P;F(l|UE8t<^$4*^U
z3xheot`jxp5<(GnHu*~%i=#I@vV-EjoWulJdwA>Iqu=9pC@-=SKZ2|&yED3UQ|;cS
zWM0A6eBRzPN^$&({-C~hUHv(tRcWnEpFNC+3=UME@hn&t_&S^kO8IOj8pSaeUqsG6
zQ(5RHASM3QZp(b~k@D<k+2rxS=ckufrKwU!SCjn#=l+f|HLBAitfOCUxeSFml&OcZ
zRX7hFpXh!xH(VP=$a*hi@%kI*va}STHE0EM^=nu459a6%IiB;b>iApL%l4$449aVS
zITVSoTs~2)EuY*yiK%wnz;g3MoCke<_3X52=ux%5>=6BwLd<{uzi@EX1j9;-(&Dzu
zIXfC%#zslZ=zeJ*F{d4caNR^y)WF>j2(!Mwa4_a)JV~J;-pbc0YR+E}5Ba1?lIH^=
z^evGeS(hb3u8ZecMG@vkubxkg_kmDF<H$n(hfjY&zg(Tt4h7w@KYB*~$;%^N@3w4%
zDp4vme)~?<yyljV?oIK_!KSE~)UTb9PLJ(VK@83zCXaVvn}@ngS0}WV>Pgy?<MGug
zvlAv^Gn6qMWDLFI@}DXJ=dRDdoR{`%0$9hZOm<b0yx04#(=yqXtms$uT;9E@57N;A
z8T$|biK%#Ap${bVZZwC1qgXuvx(PfOs0L#x@%9IAz#MF{T-2NF1|d_ZfbHFDTs7dh
z_rD<9*f+~EJTMgg^cW5FBtO)v1m?XWx9fGZG#6dUiPGV>iED{2v-zbLaeZ?W#iW=2
zmn$^1vIED$>~C#ds3$2Tmmzt{(>Lx@0_4X>%*sHz4yX<hjrsF;WVY5r93Da?x7jC+
z>xsh`bY>g69Htc#fcsRspH;&c42aGXocixU%0Q!1jxtHp72tuYpQR1yg?Do_O@0qo
z`bV;L!ObLE+(g}vLjngDI=zTiwchJ@QeUTn-1R3x1dS=wrMv8uMJ6}lTmH#pjgI_i
zn|!G8<s5d(y|^3!=Gm__S`3?C#218|CN>N@9(i3$G)u1eHp@KAkB%nRzY7iND#8OJ
z76k^2x7X>xB$Sq^PN(B@GHCh5XF~J7%2hmT_jdBECx1aOFBRjAeYedR$*uGU`Lk_+
zm{m;aYwO{=?zj*|19)?(si^a_nI9z#kL>DR`fioIe8O8CG63HkZ>fIiw^Qs4QWvXk
zvd0$Jv!5)C?lMe$O}ISX{Al&Nu{fy5Z<A_VA#1kU?~u7LXL4}t(*Hk~jurCD#p<H!
zn*q}5un`Xxu`9ou&l4n>ZlMxkHdX#^7wwXoa(9AOb-5sQX!PJF?Ae`sm=s&}cb4MW
z$8rB@>s`<^gDWvm0{=(Su{T3iFqV#oCT2KGa)?ikPWT}bNtR?jQKxRO%KI{5m)rWc
z#o@L10TtgxF3@r&JFS25cA*q?O#hSpd#&9iR(>DmR^1c7qEQRn;Xef9)Y}HzkK3<7
z@%+Jo_CbL<TEv>rc^pdy(~gaU)4zPNK;tyFnj~zmvg!$(s`or3MnpT_XGQUOq0=+=
z!5t|t+!@&i+Kd?Bu4s|L)_m-JOsujojQ}3-6z+==-ZpsgbeWO#>h)l;b4s8R<(qej
zAXwj}eCBU21wz;^lgC6cTXLC90Bca04;Ay__T?SU>kcuP38b9+HDHW^htMOKo-kLM
zjp}%*{*l^)_q-x#az-iA?!y`a({+W|)7u(xbk~^`Zj-*Mo?OKUwvd(UT7Z(12+Oeb
zEdN)WZ%$w)P<p{S_l`Rb8_3?BLz3$VUBG;n#A66c4>Dx)_3eC(X%k1&cQDMCD%r@p
zL`G0bP%@GXG{iH*$Y2!P5Qc~EdDeu6$HvuT=qU{-&oDx<zKEclBB`yPNs1@!i{XcN
zSE@HHPH9F7p(<gnCM&?7KbHaRy2?nV&ta_>h%50g;~$*OT_z5nN`=}i_|o=lhkr?d
zTjGG*b9H`|p)q#;pi<25f|H9TuYWioeunuW+fH-tWNpT%uEutvIe<nyzON|guc-bE
zvZ2}qpZVOr5o83p2(U_@-?_<F_!s?a`pUsk&9H^ytT@-H&O3Ef=n%)CgC=6yf%*jG
z;0FapG^F)cAYQ98CG#M?4P(bZDIakrA!C0~&v{#8RA2@^3u-{R8*A_eWeB%0VIRZ*
z7UM8Kv|3=1@R=P$G#CN&O{nLJX&<0-Y<JS<l3kx1H#)Q0>@>mk!9Mq14v{>R@$8w}
z5Zdh>NDp%V_3)UHkK&lJ+df-*BqcQV3DAZA01_ftF!1_TbJm4agZu_|2D=pNe`5EY
zw7y*?k8PY5Kc%nnzi)x3+opP7(fw;#&p<+9B@0NbMCa?s9J~rx2d)O2;p4Y&^r7N}
zi*er$c=#!5sE2$nk2ma~j^j(58c%ojt6PZF@}o>qStN{8BM?l-!~G21W+}VZ3JkyW
zCx2-@T-?xYlSp8YoU5~PeScT@t4UU^G3@;9Z1O|b1-d`LbXvpJ*!%tvbMpV*$bI^<
zWn@vVI31m3SiPlNfUj0M7qzQ<`Tb7b#ZsHB3qN=H{2;GgHE1%uwChuCHDxs2S%Pn}
zii^{o)8&3v8%g4B>7LQ>L&<zU%xQxB9q-^fc>Aq71-=b^iB)q08hwt3%^HtKN~)9i
zEh8mENOE_+*&O)+(1g3ewUOv+oDYd4iv%tQVypV(DUMU--4t;D;0NmeeWRzM;+S$U
zu^P-@ffx{*$EwdT`;ah8am;JZ3Dj{33F)HrsZ6NEcK_qaZ#u^@`3sKxA-%S}eT)Wv
z7Ke%#h&CMVWLyoz$`zzDY1ut`0kEje;+7-hI%e#)%+3jl3&<8GAPb4OT@U%1DZt5m
z&$Pm`?&i%|>aDUh1UL%id=cas*xuhB1eq$3zi)uzbs$?Evj&Gfy5~0kvL_xKdQVhP
z-}ha&^jqE*eui&?VXU@z=g8-d+r;PU@k*X7l9bTloueaViT*rHc$*rQVoo*V_75Ai
zl(>GpV!!&`=eNR8P)jw*P5p${yW$=YR68Cm>A|zW{CK9}R`yZA(mm$$(B|Qt3oCPZ
zGl%|D@TI+rvHLuB#rbD>fXihliu+b6_}gPG^Y3Cg--*NgBhm(QzU<?BJfHrA{a)7b
zlap3fzMf(ZE$mN$rhZbBWC}dBRlu^T_)`HZB_;JXlFD?pSSbZ4SNJCk$RWbnU((+1
z<I1rxc(c-mMO?9x{0XH2MWpu4jEs!9a^g#*9wp$D!_fijMHi%Mkd)iot3Bv8)Fk8F
z76qw?Crz?W!BO`oZ8e0Si`pjFUhR(c)L|zoG4U-b7u~gyK|g2ws3(buiqS$MA{uNz
zTY}N`FG0xVT(E@mM<VNN#RK-QbvSB}8KA1!d4weotKI#d<vccrZ@=xt;dFbtn<H41
z`;CloHvY(f<EE{+E%AndULV?ds0ugNOEA{Ka6?~#NrUZ%I*PagZ*k>D;Ue$rga@S}
zxq@xJAPzP*z486|$17b5ZA_Bh7FHjS7AvD)t>r7J(S+l_w+6$T&YCi_q<ks%a)O3f
zzNVlSQssBPt_VP^bODk=FySbV@x!|yX^O_sGH&LJc3tA_1>+o0tgz55K7_ueteW#F
z(kWF*NNNZ;O=)<s%?6LAjV3ZGY25p<&>9-1JQhl_-+Ywx{=Jxe4agcR<o)@%)a-=e
z^X4nK*88{W0sUpzQo(;wU`%&#SMx4uwrr%&nLyUD#hu)ePjxap-dMM<vHJOP&-?RX
zb9eoqCT$AL-f^n2)fkxfi+ru~NN8jE*S}ouDhX^<%oRlSAFSwQ2Ik+3%ftlkF=dUm
znj^zQ(IW`p&o_bM4&rbhaUngZH-1Gxg)ZvZ*-KZ|OZJvTp>HVeZl2+3rkq=%iJ^RA
zGN(uN=5lQIpw`unJ*33~7j`o!I)e6tcxQCdZ`nOqNZ$e?K{@{vH@i@8nL1{VK~&gX
zsm#r0R-)FuWhH}RV&6g+i!M*s4+yD<;pT1mj_av%cgX4Htqt2>|IN1VK1#bm`y<0Y
z-QErtCDsqK4}9SW#<uAPPjxRJSfsv6&_2JqB8;LLAe?2lO65+&s~xK3&^$=b!)oGb
zc_Qu!6Ot4j`;E~;juw8Tiw(JXLOqaeHekK&B)6TIiyh!-ROoJAWwSk38F_fCanGhx
z@X52UDR*IJE8%Ys2NIR(zpWT<K76|3g~Jafs*)7<eeN1qm}m>T)8G8QQSGupAe?w}
zXK8%*MK3RUiZ<y%g{L49<0mkzZ+{}%feqrvxVWW?{0vgE-}uA<@j}l{{6T>UA4Y(Z
zsnD1%4}(Fp{SdJ|yf)>7c|v}8lJd#t7An1=aJt950THiLSiHg|>*kC=yaWU(<!!jj
zQ?a>4R3L_dXTU7rMRV}yt#USiT*2Uq_2xYPrxCO1Fb#m=VY_rVz!Xez5e?7r0Y=Qj
zt7NFd6pQ<4?&CF0y_J|Iv+8G#Q^F3|o?LQ;iTXXZ*~0zAEBHGd`f53E2A1Ro*N-3V
z>Xd|sw)(7VkDZz5C@icnf86sTv42nHwk+!y`?{QOo-mu*oK7XR5LAUbiKA()0^0bj
zJV4vEVc)0N$i8x`=1Z+A%rtbKyYca1+{&s$g+|LGWcH)wiN>$-3?+ijald{&@>#a*
zI|A8bOHqVtp%%CjtpR_UDE+PEJxmHln8h-(xUQKftJGJnZO>wkdPrT)NExd=)&(!!
z>|cSVt8&Sa|IiDxg4xC!i(<Tbl{JS{4@!On#%yh8R7r&#=R)-_p8j22XCnJB)Yo_0
zN<yKQcpu^p$RqE(hR9Ci&R7x&xgm2)V8|VzCw4`^I{q@urBnHzb9`yQJs2<Y$>NHl
z8J#`ip*=oZYLjhZ#<r;g0VPB7J7pF<Y~&J3^YGPJRDHxpPX0;H6I5G)g<r_M>?f;$
zJ?NY_+GJs1c!qHX)qCpRS`g3ZAbeH7kM}(Gh~z<99=WRQ!G8|4#Cu!2l0-AwxNNqe
z-PR0I;V<(Zj#`OZdQ0Dbp3TX}(ob;{A)yewNuW5=3}TK&Vv3$h-|)x<a<0j8b0lp=
zy?Z_W`T_1B?=CiXTvN^))AZgz`|38w2o#f^27A#T@n84m4g5@({0$-EY$+yZ3_D&U
zc~bH8qALH)@&7nWe(nh}hp#`uCiH&iyjunXPHlA(lxcY^t6Hq?tGatMA2j?!6_V`!
zCSQN%Y9^yczTEL}Cj;mG?yLRzlUr$zVzBM`Xn0k-G3~5?&Fv-HW1Og4YDOI*xyPSj
zTf6YTSwM(z(D$11_a!&dq52Jjrcd%;C_A=r=6J6NevX~?**X^X`*W@xc(^tO+Giey
z?J_|W=B~GeS2X|}>R+OA`~ZhHYZ)l+`Ov63+zdk<f%Gv0(Eo~!S+j@M(E$MP0Qn6t
z>!w)30}M<o<B=F4(BruylJm1`?*znw%quGekx2aW_)M>-gELf%z0M!b7!;&CjNF*n
zsHh4^_lB&TbBWm6TXpx0U(KI?fDPKTH2CfCA{3{;ISM+%@H$oLaENJ(!8~2Yg+BxM
zP1-gvFBpVFI39!7F2l|R9;8NnFnF`Ox>yn5JxBUiQK+7KS%y9SpoBw%hED=1ECM-)
zap*z!AE{Qp)@i{HB)v(MA_vE0D1o=k8muFv6`6^Sm+xpt07+X%lqKi>uu@C9|6%=l
zwrGxs^MkS8$=?gdsu-VmCdpUkiHxj2ll;S*TlGRWaQRRjcj;%spO5u=3bswaV6~|u
zdz9_CrtME{qo4fxbrrYMx5*>Emy@=RMXzwSZWZbWcgcL#2g!p-Mlz+1KUA&%Da}*)
zTOyD(h_mC~E%V?SGBz%My{{Pc-L<eH9QK0eiP>*+X{8gKrUJhD!_D*7u%|ocAJ-J`
z`IZ{}XxcD%=(uzawmC=Ndr}@i5Kv0fU^9%;&?{`U<xrz%qW843WiELAX)(mWIEa2|
zb-#8#Na!j+Rl+I;I0#Mb4~W*xH~luoIqTWpvzJj4(Z{mgHl;8=v7x|K0*%&b(*P@K
z2#ctc@q&fUp^PQp`CEaj1-;EDNx8f0qX@^YNgDA;kW->E+`hi>J)@7=li>n>D#7Ie
zPDQ~qslOlpV-W$D!7r{=o?;uai5mTa(Y?{h6#J6MslhXXClslPJNZs?G2=+4lE{Xk
zXJj^$JXS}xl6Rje=|N-AXy_#ck_X5{c~j>!eLZ2BrvwCI#7by=SEon)E+3-A;j|IY
z`Q;0*4!#tPfS6d7*B@9a;=f9#C2-{giyW>#2+a#V7)~OUn+D8UR(gXp6{u9>vDWT6
zpx*r#^CURc<4~id4LVPCx)NX-kYr#|o&3Z%X2Htv&izifUyAwKr>G{Z>el<*bvSdT
z*}Y|LFq=O(>r+$T8)Ujb*3sGBoxOgy>qDP4<UhQ^8|p>#B5md>%b$Jr|D~SAv$>g8
zA@1C7^kdeB$G7PXx*SISL)^-zr(B#ll~fb5UG$TOTVmO~n>!VK>P1qwf=7sBKwz@u
zkA(cfCELitVQcG@b(?wk=Zb)kz`jpucqPhvwGfxDeOScy9qj?C1$2g*psZ1hnAiaE
zMAqEbS920mMhFTdTQ04E93tAUomV(xDIGao(LXn^2MVk3jo#u<4Lvv{_apYlZc*ux
zR=8=JNO@qa9UMnei+2dYVyE1MpwF}!CnRrUW7CnRNfT|Tj$_Eoee0MJk2&N%HqLfO
z8at)Ks|OGQ7(mv=CKqTuAd5Px>*Z^49Mjon#|85Kj=EpBEoWK>@8z*@->b_>#06+`
zV|>FGCPj7sLsNYMsYB0t6Ytr5<O&h3X*gv0G&*YK=S4tBC~A~3I;tyr28s>V+Oij$
zaBc9!cb%loFqskA5?Ps>hftsI_d+RbplUY@g}>(|w{IM)?!%>!TZKO_uUd6Eg3PL5
z(8yx{nZLu+n}18cwur?1GT|RUtYpz>H9hY+y|h8fXI+Qn!FA}I1%hBsl(u&qn)nzq
zyFy$h=(G9ID>rhWxg(mGl2Gk@oWc6>XS3?h=m5Zo?_ImIK#j^DMUB=!a#K1OKJ)i&
z{kkM&47dL0`7jmrp7~Z+<CV3Yg8(eWP6d@~JIjiWkP0+1g4@21qApo*7pso8F0f8@
ziXA10q{yXXi<C?Ym`S)IK_xYe)+WJX`6(MSRbQx16;91Rz(`7S0ZWi(P-7(0XbJFI
zE;3ITIj6)0;jZ}`U$DiaDBAoS>h4!Ki+D{k{G}CIL-C{i=mJp!gDk2Dq3z}B6xeGg
z0nb!kaltdwhSuNgB5U;C35@AeJz$S>^mKa*5|AVv0?Rq>ba&>vux{CwW1JVBXU0qF
z?I#s*1^LTV%Y=K=tC@KcA6bRVb205xjp_lceUUq-bpQQ5+kLbqdv@(4`~UYuCQ_D9
zi{P{Ox3bM~>b+8z>CeVLcG@p|q`vzXjTepN+D2wKGAWqVHr%&F%I_c9A7bTWa74$H
zQnR0fIS*p9Ldw3syE%36G4AblB1sjK?qCm$6~M8`P7pJakKNn(6Y!Brrohy?|8D5E
z1mqQh10k$Jg~#-?b&HyB&D-j{mOBM-1Y6EO0d*CX6^?)*O2EmNL#aL`>W(Lwz9q1;
z5wcHw9--{J4BDKAtg=lg(GN`ryXqqPvcI2W>C3~N&RFJz@Bk|mQK2sS8A9OpgS!+)
zfRAs`RiR3)!m?r(<*<nxfE7SlEIlZaEWO7X?pJpbfn9XV^jl(&-IYPaW-@w2{%-C{
zKXx5>aH(kcCcqtw&YB7WmFw$`eW|-pyc@%$nv<6UECOT4v@^p~?T-#0v+!jr;@b$*
zth>uE)939k8WUbINZxf`$0<jIwjW{IALkDD5<SNaVUYKr0v!5|Vl+d5B%x1p9g-LK
zxGrHdSeHDL?-Um$@8R-2t{WQ_q!ZMARr$iE`j6>BdAmxFq4UgO^FNtYb^LwR4?(2)
zg!XuQnhxz<T0T`Q{EJ$Tby(J3J?6)LB02r!q*~ZxWB2pWzf23i;3_L}1M6S7prwp-
zVcSEFY^=!NrD-d6<Q_v!&+-93X(q3-I;s!0AaVM`F{0oQsn7HqKzs2Ep@dD8=te=j
zBh1Ry9*ECh#+&U>!qW{Oa=4d~Ny}CPLc_Z|`||&G`(P1?jtRHH)~1Rm$=a+2E&O5d
z5DW?B1793GeK915O|9a8BzCFdto}eO(9%asDFZ|uM2o>5{+7v;f{LMC4kTmavX(+E
zC|$%|IZxOHY8Jto^C1~^zQ=;$8MUQI;!#Dh9d?>2m;<_iKh0VN0doPzXOTqQa>{e+
z<%EQB5&vBah(55Nv<G={*p$fi4dMx%xnC5sD~^f|%4^*1hP?=6Ip(?~A0aUvOYen|
z5x;h<B}t(c2Tpa#{#pa-hv7R&7tYQv&PY{+;4eu3`d{!Duyutoo@TCh-1H{NsfHB}
zTX4yFqo}(WAjPV?+>tVbmpmgm&It-?@~?wE^zRB2j^y%!M?=eae~{zQPCi2L5J29F
zrs2$cZL*rn2KMMtB~tDx^}aoW5|U|%-eBR-@5esjsJV78-1?W;Su~V86q6nC`9s;~
zeyqCn5&0J`ck=J$>*Bo3xvf7X&OG{3G$t4~T6J^ve&lm^(KvEWNQ$T(MFc-OU$Ng)
zZ=u)^kg<z^N&q++t{I*ZXVt&vV)R#_6etcLdI7ywzpH75e1?LfK%ZSs$f@a{dEjcB
z7_<KyCh=z+LkBJP8OR+G5r*EEd`EI5-qH$CrMPYqqH$7$>g}@q_j<mB3%_}jWl7@s
z1xTr%Y)$~4q8)4QBD5U6od`vO<AmG1iGh_Nqrio|kYS(PIKZtRrVG5VIRWY{dOnbl
zLDe8oub97c^;Q02#vhWiYmSih2@5FmZesC!tx4nv${b6K*s30Gzt=?9i<QuF*qnq4
zNeby}#U%9{xn|n~?u65WrltuP_lBrYi@QueQ9n%xR)$a9)$c9!kbGCD2EGP6pZG}R
zsi!v6wz!+(Enqi~JukQd*sPm2-o%Re2)4A7%Iu>qFr+rD*eH>A4I%TZkf}ggpz(Wn
zV0g>xuKz*`Af?BQy9WU>OO_$WW2#+2$Pa>$2Vk(n2)fJv{IG-Rhy<*Qr~8~anZj`k
zLsNfKW}I-uaN_Hb6+G2n-spMICA7gVdCuy?9tJD|#LUMZrqYw!#LHK0;YxYk`LQ1G
z!slpt97~*g@V2_OrxRSD4+rOPJHu00Q$)QHfR|U}&b7gzw?HYX2z+7Ye6!W>h(h&^
zT;a$CD9CrxqPyN<l~>I|%7m=>BA-T(J9)1$gyW}oSpw!WJqp4YiAjJB-~t$uC6X`t
zQy*Xt5KMry0IbnP76<49VpLZ(ZjSRck=K~bf~AQp+yx$5LkMFt5QK-CNCqd^+Cdf=
z#azjNOuu#n3`KX<n=V*gSrK<#40D4}K@4qw2;IT(isj1~T=`>#4&TO~C<y1?RCvgc
z(me;bFti!DSeWzn&IzMKIGFD9b9)yd`6J;QkZBRaD-_>x$!@$!#HjTWAqtQxM>kMP
zaLLaoGJonHiR+j_K@nz$9I{8)1k`L(TInAWxJ{bOn~cj3Bg#tTf%E_>AqTYK4&q?n
z=;fye>FY|YYs~ldwS{Z<v-jN}zf$t|uvmI3e~7rJjBhi9ca|s9&f?>)_=BPXCH}0Q
zW7Y&DEsK59uAxSLf6IyNMrtE(C!uP#O#4^%!sHAxgR}rv8d1$#>T8!7d;|MTP49OA
z0(-HevpZkW8q>ryDFt;0o-mnO4jCzc@T&tJMz|4zeUL0f=>Gksw^ugDK-9mP@i_r&
z8QeTH2~Rifj#Y#Hh8l(cdYNI6A1Mm=#xO3%+!8Mn>|+5i3)@o9g>W7xVdmT&P)kjg
zOXZ2z3w<TB;UlPuS}fMfQ?djerK~e^Q=ZbVl4A(zI&t4e1#zdLJ%lIP2|64gD-drK
zdpt@Sb8iyJ??w41`az`td=#gNST_KKIfPk)UrQ}b-B*P6I9IQ|5%jUNLcTzdQCHAp
zmd_H8cquHDJ|{`t^(`5a^+f3nG?$`|HUsiaSHuMt67P(KF3L(-#{mS^Wmp|ZgqE!w
zpw9_RR$gil$!OBZFO7!>e^q7Fz3+MBb){tJi`eBht(cH80OM97>*2DjVt=w0W$r-{
z@6RaGXh#R=Qphgmi2_ajb$KE|^@mF~<LZxpw*2|rFPB%r4a$+h&X6*efiT&<E_w#X
zk`sdAL?#D8DxeZRVOK9-opdfxV?eITBS<hH3NWJJ>tn0fQ%*z(FZ&2=2bI(`LGFW(
zQD8h=%$v+_HqH==l#W;UiUdb*C0RVfW1tsR0VJZrvHUivU%LNpt-#m`VT96zc|@5+
zj0B7M^MD214v=JPQB7chcB(w->Gcw_jrIB-=WPPu3iV9V)zIb6fOn&}mj2=+3h=DY
zxdelw>ih9xwp?h%p`T0G7c)*NRda7qv@~>|Izf%Q^c*f)S*|zhyB;=%_XO8LpY-r8
zZx*8}g9#F<0r+C|0x3MnVt|9~*9}&Hcjk3$*!6*G+wK9=hG4}c;De#*k2H^#?bd-d
zah-cjtn1e4Ql#^n!>Q=SRV`>Mq-;ta)8DU~)Rp;1<G<t$lHsCi)V$@6XiDGi7}zN^
z|KBWN2r5BmwHJzHVEmMZ!fw(V;56-SpTe+JVD6h5?ZZo`DD5u}SFv>g-8qh-nxPjQ
zm|X&-ScPXrJkn1{cbGHhu8J0p!HRm535dDIM0q@5BW1%^9H=ga4l=W4hN>|G+Ij^(
z%YY`hT^3_CvhgCamVhm`o9V&bfWOdPv`mJQt$2Nc3=o8}pW|1Hd`@<NHRXihv_Uuf
zXS}j4?TKeD?O_f3z@bh71op!2jHkp*gfML7P(uLm_wr{IJ1m#3aE1{B74Zs0{qAxY
z4j5<#)u5{^391#}j#JTxfYO1C?Unj}b0AIUFKtC%MH9*cCG4gE`4gBMaPYx1?>-P+
zzYzUA8K7aB*Sn<brx_s~VBX`9n`?q`Cve+yW6EatLvc4E=X#Q4r#B2Hjq)DsMenGL
z`GL|jaZ{vcLF}h1M~KIZcj|=)39_eXx+eRQ?B)*$3Y&<>9nLl#;s?!V^OP;VLdN)p
zuZG}JYCy7-D<2!aE~u-3f=p{IoA%C?L8#y^<by3g$_wjN`!R$jL${vg38oz(MaPYz
z;PWutxZeYQR??9XuoES=kI;<1dH`KBzI>E9FB%TZ|9xd!T!-tAV}cZCNtR}#FrtX2
z^_yt!ezl#=)s@tjbD0+mP}zQh@S)V{bTJ&5s7gvo(OqKHOs{X`Z)_ygFi<<`YtO29
z>;p`ub8Mr6;aNL}zW61@TP(hNJHU$fij+N>8ykiJe4-(tzpt0Z@8*KG4>a&GpY3H4
z(~(2iKbFLlcug!;;`hWyP;%{1O+UFd$JY{TxZ@PM=lg;Q8_aOaVAxIa?b7@Rdg&lw
zF6Wdk5{qv!?y*GQ0mU{266@BluQF8JEX&4V|HMAg7TRG=;C83-yvR*wn*ud-tc}eE
zDGTW7@*_FIHSwZN2mg+7rnrXyO+;mK#D}n^<>7n%cXi|#vgOt{B@4zFO{d@;Qkx-;
zp-!z2{(wv6f*_?7hPH~|h89p?@ZTDeMVU<%yrq6XpsO->LIhZ5<CfFOFoFj^;=--=
zH{1aW<#><Dtuu?Gq2bfwrysc{O6lE`0RZ3ahx{IF2q9$M9diRQ#@XzaTy0-8u-^5h
zw+PMqfLR&W2Izo!kW9HO2yqx`*X!lThU|)SzjBWUCFPI`6E#n2g}y~*-!H69Fc8i(
z9N4;VsuSzni4JchTdib^Kcla`7dlH;_3zr4%Jm)cuF(uWAnGOh+xP9AxLScwsz@MI
z1&y+4cTX&wcIwoFZYSe+BnYzBHk938Z^4;2g)91DEwa#*L+m6HG;OYgk)MOL_&;Bn
zD0P$ENAH+gM88S>HuaT~hRUfw=-ufsY?K(UqbD_WVNTWD_JOS&m<#+gIHDex6O~2e
z8MAnHLiB^aFkT8l1U#IsAy_cqO!!bgEUon(4ISilC(REJ$K9^d#CByZe0KQf{nv02
zNEujn+!VcWQQ>nV5mG=(?Knm<mnN`d?OxD0^qYxHZ{5hFCD%GJe1ubl`G_iO2uHSX
z%eZ^|xn{@pk`vX>sRZv{1vS4jgjbioBFoBuhfyb;LtAF?KZv&oTaLH~kDr%OpC28@
zkB60W-es;@5e9G;bpAIK(``roVbj3w#y}&>bg=_?T{vu{#uuQ@<6C=zG{MJw`}38c
zN`07*yS*CaV+}=;Q?eE69xky=sl*=;>p=wJ7X57wBX%@2vVk%zZ9m$HDDAxa{*>wn
z<pOeW6Pm;}-a`Q!zoK10aC30-!@grrH7rbd=^gLBwm!{b3VSPfwn!XGdjnK9&!Qcb
zpF)I`w3lxSn^6HMflv&fJtc#B0OSM!To9Y(dD>a>3Mj@=kCjyq7(65@5nU!aGmzhm
z{t9=5etOO2NeU2?=`epO0Bs~e7&lz7l$mL0qarV;TVKpEdPaT>v)|YkAST2$g3XKb
zh4GQC-YC@DE;v&;SeP~Ky%~_aUHgHJ(8_six}-?G0%?qS6e)Ey8$HEo1M%1v(MaQw
zVM(BCq7P1X#P&$ku-#SgaUQpSkk6QJT0?)30uY)BX^GNPpqXr!>;_2g<mc#3&Z!N|
z;Nm7Wb1oM0X7PX~P0E2Ue9qM-Sg7(FK@(_mZ7=Jio#@TPCo>{Q#PN){aDdPgJ~y%G
z7IVpuf#c<xm*{g=Dbo%Lo#3FWa!KT!23xQF_HfnO;T;?k+8!ts1_zZJi3DC?=`}9K
ztMe?49g;XaM%){53fsg7fWtLBO2Q+2*j8aeu##9AS~X2Znr^@MX)ms6+nRT0D*pbP
z48~E2O_c4j8j#y<SePk~LCcf~+7lei#jrj+e08xdb#Sh+JP)vSw|B}~D2D%G0mx7v
zw(@KL%y43Y2~f&~Cc4vi8FKAl9F>lrkuB@<y?37Eb}<_B_;UpN^k*&c<}iYC{|{f+
zo3@U15Tb9XU5_ekI|LSngW~RXSMh=<O8*t?6Qw@!$Ka&96Vvl~X~ldX#ZnaRL&r}?
zjcns-d{lEf$qSj%mU~P%Wiv*5CAfT~-cs@6yhY@~)@j9_0Db30zR2Vh{qr=RQ|P0&
zU@R{s{nPzb$B2$s{Y#Gy*Yn^)n%jYd&j;EWhK0v`;xnNLh9md|1)2!N8d5|@b>BdY
zela572^3<WvX}BF09FP6eKx+&L4ZrXqZdtROR!1A3-k`8zfKv01;f1Yhb@Ad*DGR_
zsvr6aQYB=6P6l(5#3lQtmf$}IMk@lqR_qnDrM$xO2kGjMA^Feje6p@ggUkT-w4O7D
zC<Z@C{C2D^2Dr`ZkCeEU!k00ivaih+s<B95(v2;aCR{6i5bkrTQn-g<$+HlePZT^8
zT?4#L>3Th8whsbc#o)vWO(s%Ly4LyO+mz(8ej44s%`F>~-!PD21-uLka#QwqtEzDA
zBQvAVsP*5r{OP`U`QnO@hQZ&MZ7;}_yJz>oyw|CW6aINuu;klPF<w)305@omzwfiY
zxUQp6h@F_jrvsK=_gwf)VdrBgQs%t%a31mj53q(}sQqzizASoo_OO5o;d>@}$U-Vu
z6>c6bjIh{Ip;Me}v>S`ig;S6YUULrR=wS2eRO&Z!`f&89V)JKda)AvS1ff?iZmY1)
zB9{wX5&V55ezA``ij=jfccI*NLDoVNZDqV7F(Xv_1p86^(f43Kj^vV9-4p`>UCjMu
z56$0+lmKM%4LBv45Chn5j{v0^f{L{ej(9|ti~PUY90UtOmw!*70U?KCL`lS;_PaXY
z!r0F?OTU5-<L~DAgCC63x?<~zWV^m7J~mdP_fq$1&)x^UdV^cxgXLL&z|9paThY3W
z`g3r7w@cI;bqm#1fu}%@cIJDMB+!0n+tAs?Ml73?yM*Q|RC<2#DQ+l(k}x}*tc^P4
z?d{1Mh~d(G3S|rL=q?0FsT?-8`h9{3Hf~dkK1p>N2mDXDa%0Xa<hqZ^$vY@R=x(pv
z%BubSoZNL9{MY7ZMt<$=Zfb-SHf$QV`fPr`wFxiy>ir<vt(xu7E5(SjPf-zeZ8Y(h
zlt$oZozZ%z_*uZq3c5r0fW1_HIc&m5CjqSb7IN|Y;Y0yFX=A!Y7y&d26!$iKWS^0U
zj1P~J8rKL?Vr3T(LQw#IU}MB56tR<^-P4i*KvaL)yK7mYb5o7Xcu-c^6cum95+TU(
zComz4W<L_cC$!dZ7Yr`tYG@VkT61!H-o(p9UF?l(8ma8@DCXGv^PWA`VWB#M(BkBz
zai7qDi96A8nz=iV=>`u3Z>^C5(@_T9b7$xPbO+&V>)ciVs?^P2yCr^C94Cg%?X<;i
zjbTsR3O0$Be%#W1<@>c7*X4<`oddu7F%0=Vbcuc|ZQVa@p8U1{@Cya`(liMA$_*_8
zC?Hu-k9IJLRpQ!y!#{&BnyRsmvjzkj`6_On+D=QIEc;Ixi3W~|vnIS5PZuGMQPz2@
zsY=K&L%OCRmOr*O#jbF)NcgrJd(TZHC;q$i8pp{)ffxGkgIxu{E0{Upm~SWi!0;J5
zKk3;y-osx?1sP%&K<hC3;R0WHm?nV2mZ}i8z=6EPeCQ)gep6qd&~s>u6jp9N<^;&j
zFZ>DbpHDfOf7rGyJ-hTJ!2;^L>9-%QO}oEHu98A2=Z@7UVqR8%8I(Y)RV1%sD@cwL
z0Po+-1vX-k(7NKZS#&lJG{|a$VUPImeIGXJ*+&>ksupiN+kF%JMTQ!nk2ER%8UA5&
zuT0)#-=;C<6P_6s@|!Yt;+J_9a~Chkhv~rGFV~fmBW*gv7$Sjzx1aE8YP+EfBsB|z
z_MfY5L*mHkLPD@3J;+@j^T<-N?Nx~w$g#e)eK7J$Sa>A#=!HCMPZ|QJ$$r3vL%(9R
zvZ3eD=AFu?F~xZ`7*U1Yp^G68ao~i{Q8(B{8C7N){-R@CBZ)^dHa49wqdJ{RLLU->
zOxnV4D8A1DWxQfMU1wJ=BdAJjGT=o9uZ@$|q3_l=A>7;I*}kY7ul@n|ai?Y#9MRu8
zsw1<p7aC{G)78*LplIuWz(jf(JNKzxG9pa;1lHjCCN=pmnU&4j5i=osIxr}I47osy
zj$)~KJWd-wxsm82_+D30H!&$4_;6b;4rc=18Wq}q{CXP6i@Q8x0g2g~|NeAB!+MNH
zRjlnBXHU1NuSj~#(Y!E^KF$vL1e<Gxmfw<hu^@Q=w+5aS8@zm6Z2k7rYh2b~p)!^c
zxvTAu?ngpm@h{VMI2+}XX{u>d-05cD&pte$u%R8;f_SEy8B|ZgLW}oHE`&XJv}$|u
z8J?7j01Vl*Q#pR^Dt)tBz-BlX;-}KK?9-m_V!zsO7-F#LDxTm7<hME4HVbuj3wp(c
zf6jgYx3`pL!xySrz=ksn(5+Nw9S^d<Gb%Q(_>#jt;PKl8$B7oEhVv!6E5zyHATJ=!
zCec^_B%A5Z1K+dHd942h>h2_L;b|B=L7B-Y-LD7woj@Za>+g}wD?0Y6pP6|#D$07V
z7Jf+BLi%2GEk*x__nvI8F7S0XUa2{MZAj_i@6T8wi(fSCJ4Z@}n{>Carm^Vx!fgac
zu;gZX4T-mBhO`}@>95V@5UH*~ycK(tp|1C}5L4!v?ZFqWWp9PUFdHTt-3>Z7_=EW`
zkU&60g<7eI`o^sgOQoS}cB$LZM<PsY?9`&so>w#0-*+E{Nw|yWJ!G75*rrzJ13VHZ
zQSxHdlTs;<NxHMUm5H2K*;q<RzP-bl9aw1#Bst+kZQEE6zbbMU2%X8eXX9TQcug~9
zHlwg=H-A$Ts#$X|@4SbVY2n&(BLU)_8wZ)t(m-!NlLsZUuXbS~WY6L9(SwnQ-xcAn
zvY5rXII`S>Am)|aJVS;u-!i{_>W+tr80g_7-(+~yucq0+rgwbw)kU5F98+V{Ci+Eu
zgWTPP+B1Gng)-5)=V`1j{x=ICa?)^K=1q5kYdKMhbySwhf=k`V==SJ=l$u>V^FXvv
zXod1hTABO2_Jply$)a%2wxL0&UkmUm&KL#FG(_C{?ctC0zVG!@#l{ymO~zEpCE4!Q
zPFIcKHfB-*CmC1C*vIDC4b3Iu?b(O98v5lfbE+}mug}zO3aA%NMxDJ)C-PhO^}Ym@
z^{Cotn%~a{bw;5B)9WL@@?B<K|LVTqn(Uum0!wt8@7^>T=v}`_0?Yd*X?ZkFpGx^W
zVo<M#g;ly~OSbZ-*lhQ&Sy#%vo5lZ@df5|*{8|-f&%K^a6{K4+xE4*RS5`9>J@a`)
z$p!()X2-RD!g<PDk12QGy!}-CglGto`>a;ZQ~!ZMjM9&66j`E)7L<D!EzIs(-pQob
z^^I`lTjH<(;=(NVd;G|Qh8QEI>drsy*jR5hEd1$a^dKsulYGklq^Sl*f+%-(s-1h<
zj1c*SG~Kq99$I+%vP`6LNc-r?gt@Np8=!`vt^9?n|1`oJYu^}Ygc68=xqPepI0i!%
z6sh<Rew4-sa`Ez{>Zfa}hN`(s3PF7bV}vrdxpnKGp!uWh!%~z?dVq%k3!jHQ{f3p?
zDI6^Opk(U>AJR_<#%C-ytvySsn&p)8w_$s48?9==m}$<;p13nv8eAqnhwc4cODLO@
z`H%8Y%G*bi7L+{b+?fK_s34;SF=nq|k8!#vv2`&&K}d{@U+wP{%v${0N_Q(HV@0nV
zwFJn`E%H68)xc%46H3hl9-cG<+?8K%7IEe2kW8qfPNk!Sm_P1M$^*bp?rPiQA+}sX
zp({Ho4=S+%pu_K@=0d{a4Q#69c{s%TDA?r1dv0&o9AJDJpH-2Dgz}NCXnxyN&CE;<
z580(LF(;ZXTQTi{N+SdV)nmfHqrc7OFxO*4bGm0#v&SVzKKkJQ6~vVLr>!NFsIM2u
zWJfwv5K_LUa|D5kvgi7z*|OR9@0dyP`5v;Qu1LYHpnE3k{0G+yxBl1mf4EZPOgEj4
zyOP7M@&a7{C@-&%1V6DjsA}yY=gOitcM}&Sxt`*J5{iKUc(kl|z~iVJQptzfjltT%
zw=v>9PmSjof_8%troW1B|IA}6+Nn18*&61s*EWjc>(ctCu`fjs3UG_3?rZCE2@c@{
z8d@XTq<9dON*Uk7gj5{N0TWtBtQ_v_`_LXc)iIectd7n-ht1vLbpd(sMQknB`cIVX
zu`mwf&lE-KMzAx$N_z%+lEMo<jelA5+Kr@y`<_*rG>HPwpuk5YKr-63qTf~Zl%p}{
z_PD6vCEc?6k=^6XIoZXJ@%*J?CT!dbjk_;(A2VkYYFgHka6~94<t@B(tI~3|U+uxt
z+!8nTuz$IjzM*Iz40^91g*X<Wn^oKH{B@h_+47u>L5vLb)KwLg!fv-z7tdrkz>_FI
zEf8<BBJxFv@*Ry%;7U<Kty2<LR}aa#E>qZ4=t0Cni1h90kM&L+>l(+olS4PV;k|5X
z=dhzmuV3OU+#MO#t@5uLb56SJwv-vW6Vj*IcFkVioNwAa?;?@jBM+vLv-<0D)8*n*
z`q1pl@Ruw+d_Z^zrCeHL69v@rVz7113-;hv(^J|QaucRfA|#u!onMamDD*Qj5Liq}
z@4<I<X((r@hnm0KC>Z#fqm?tDdqE_Usl-MXqha12O-JZ@CYc$qNF`zIGxSI?_wdn%
zPhY1I`2zxkbfNNkRnE;eFbA<9`l9u$JY0e?0A<~Z{ZrPjZl>F4eUKeBW^{H%zIQh2
z^j;9vWSKDz=pxBv8WY@1$foNi1*{vm5)#W96KF^-Goy(2XyVR}d}Z+iSY1?()noc!
z*3%%BMUQ_J$vqOfxb~%0mh~yd*6bH<R<rpI@etIJ!#)aKiQJ3hWVu$kSZNKK`F0Q`
zI*bR~i9MNo)5UrlN`H5zoXrpxuv@zPvA{T!(I`jodSiMZ_33y{m_U<Su=9+Q*R^SS
zx0dyV*;|%L_D7;PeJgKEWKVt=EaxX{6EM1cCjJxn@#PMat`NQS$UV*6EUb#e9YCc&
z#@C@`f66`q+kA#f{&k)h<kx0d2f;H~A?>2WuW-xN;lalC{GM`8#zR2wsX6u{!+CY(
zgsA?|Hv<O+uk%0u{daA+0|*@9mPs@!Ek6DYeAB7E#OwK7TFx*|qfCzZE){N``%6V^
z@O@o3V4`6_rEI7r%`j20#hGp)!bbui-LOy-&7mxnePUevm7NrBF$IvsG<>LTf|hIM
zNAHP3F?-sb$DA+24a5c=HftM>hNWR0Zb_&tYc{WV69n`UPn6{*<5%QB6E?-qSQFRE
zE`^-4@(ZnJP6K_HeBcRr#W!jzFbtfhgk4K!-;SOw@5RVSh8}D!qz)CN1^3_0v+CR~
zj|^<Z-|~G|o0HvP_BzE*A5JHJjuou`ao9hvJE{*MlIc*P=l48ws{T274wN+)uKY~4
zCYp{oSvalJri=Fe=`@1fMq1xWHJK=FGLXa+y2F8BmZZ@IxKZTW@8$4`Y93Tg2BBg_
z0Qh#&kv7z({+HSFsIE_E-A9lwhO0aMwhH&+Wa2g|zGFB~(L@Y;=6E1}maD0B*EYIK
zQYV}#&>3KeqFUH~T@Clx6JxC&8V3T=Hp}F!C7An842vFVEwd5`<Hih2li2UP>$R;n
zZZ?E5pM26tZE9_YXeZ55t>bXN1NPfhQBhuo72F0!kKE*Ptf7NQbmo5Em#_={rE4Ck
z#={mG<@MG;=jxRoJ7BqcNN*t9gPe0h&G-(E7?(Hh&SvX8N*>vLsr8@|6`K{2lX#vG
zF#ol|{^{LCCs$91PMBlx`C>=J=44@d-bj<o@b#_rvXA%z_1?mIM>S`k6~U2x`-<6{
zX39ymDf8r4J}^?Tw{h<w%#lh@2K>uM8fG5re0h8E1Sj?Hm?|r?9DQK7g^~25==VIZ
zd5*YXS1w4XFc=#3ND%*LzB(C3{ZEoA3;wgGA>LN)kZj-sN`P(R`6IC!J9|i8Wk1xV
z5nI!h-lOhMwD$+K6M)*`X(i?Z)SkGv1{TNjmEBiV`Y9sOtyH+f!xl!r?|LxM)afL#
z5i8go?fc7=E0(_huWBxY?8lG=q?EvfAY1Q4p75~8e+9eWt=90-JKBe~eU-B`Y-*%t
zvTOGSwfMZv_^G5y^4_O4rK*$AF#HV4d!el@mbp_sX%)_NuSf6M9hJxPiJlQuZ3!s%
z<~aSMIcY^*DtIvxum)RrZOvEhbZxt<bW<Q0!b5Yr{B;RizP_yVzq_9kRt)0u4TenD
zefG=8n&oeDnryzD-yB&p%7@Ks9Au$sa9K|K=(choQvzO%?Sf7F?SOZP5=>f?7{61W
zzrKi1+DhyGVZA$%p{hk!#iJJqGrzC`HVV=kVt*Q2%T|cMr$z4HW&EHRH6DkV@f94s
zz#<qAl)7YV*OuO)qA}x%$AL<8EZWTgWRQvX<FS(mJUW5@$JAFwMfHAdpP8XUM7mLb
z5(2^yLx+JyOZU(<fPi!jA%e7sbQp9E-7vItONVrK=X+f1{jc?WnfW|>?sK2Lui9^~
z{*w997HxESU}|MmzA|)m1>d<DVC(cfUyh5bMmz8H12PBrv^nRSz-|e;i^ZIx3r`+1
zK;7Qu3#M|ueVK4w<Z3|O$mB$nKHM(ma81z3<u6-t5ub=m50{->oj9UGH^f|^T{9WR
zClwFg$l(Enhm>wuEuZt{0DXb>^Hk5BH<dL~&>BGSrGDB`1n_zEv~aVTo#UYf_4}-9
z?2)3ffMdD$7qDUUzPFT3<#cBBsof^^w$-hD&WDAJw^n2NGHI@3g`q$A)@?_1F`@DL
zsb=J1WB*0u*}mgchihu(9|`-rL>`v=nr&n|x87yOstHe&g^i8irl^cBU8+7!=*8bp
zqIlIPR{!YQ>wCl?<<<;RFy|{tuVS6|{-QzNajY|OI1Gb>u?G1pFXTC&7nqu9uO>{b
zO{uPLYm`0ie`wL&A_GOrTb}9QQh(DnPr$f;wnFofFF^KCX!_ln+JaJ!&wD<Xl5T<X
zBP`=7Qr8Z`3O&&t?$k0d3UCBP(k1~C>VoCqQ7ZRxX`ANOSoDy@N9D9Y6nYMfLwTqH
zc0Mw|MMp{-w%aZ$Q$KuluzsrbL8rvp2bhc}&Noi;Q$NjcmA?<a@DVOtC?nL4+R@Et
zWd@uMI{t%Q4FT6(nb$GW%XG1eqN~ZOKFWcJj3mTE{T}<7rC#?7u75WxSAR5TL7A`j
z+TXLrkJKTrQp@$GZ?Q%G_0u$pB4P$7<NC!T-ea;?hb;P%{nFI#UC?tkXOW9Q)wfgS
z8wxR`bLr#7VA8dCJiFR%q_bT!3zx#N6a~JNlq%y&8#1Nv(82L7AR@F5kVvW8e1C3(
zC6{==DJ86n>Jy%{{Q0gHd62o%u{S^h)W&n=_hVj%NIvEh=HAX3zGFbgw@72?<$%1c
z3y^u5QaAIfm=^L&IIVUZw+_>o!-$Twib**PM~Y;u9}$e}+@+Ewm**Di<&{Kp4M;(9
zQ7OYex~~<X>3Aazdmnj8mN_-kl+2<c_h~l6NKcc1%%LwdF(mx3pn76}*NJr7*!VsZ
zV$2^JU@H+THQLnrf(6$HVzvCM=F|1>Uro@l@c{*09zJfbiaDQ4yOK!V)SP!Jcy+4F
zadvKfhPOLp`&j8zx<=ir+gR5f_vJed&Fiait28}QoCat8pN#hnXEh8?H~S+EY81B0
zcm0;f%#3%W1Jd>L^d5%CdGh5)HhI|{FZ=d{lD=V^`}a5>-NTL#Q1XR9`~km6->bz8
zJb%J~-U!4~D9=be8_F+>Eb}hgjuH8n3O*a!Zzm(R_~xSv0b$-RM^{8$%AF5gWA0#7
zJB&UtQ4@x7T7aHfKirCV(S_iLE8$8z8Nky1l<i>5Lc7>OGq8tz-tktqzTdRnzUvhJ
za@@E_L|tLHxB3LgKnu)U|HZE&lHoc)&paL=VwGd>6WOMdAU>fF*mNz`0+5~R$%yEf
zef7q#LG`XGl;26LBtj*I-bimj(#NDF<b-XHFW2oOW|sQ@&w<-saO(d&);OQDKXfbg
zB-Qg)4_Q0VykAOF$Yf)SQ2|2=Q=ByF_KHqh`CSdE+vaYIz{O(y(rJ6GXDxHoL;=Ai
zBwq3~7w~wlBE|W=si22a&s8tfHMAeu)vRZJ5Zxuf>8*_)VvpJUt1ysi89<77A5Y_@
zhkN%Ai~JTRK*%}HYIb0*L<sbEOFU&Ce<5S)pSxS5W9_nWbEFIIt9a-}mfaAiPczH*
z5UAX3xNLtVeK9!1ZvD1qzn$Sz(Xi1?v3rlUo7;U|#O<!{?PY*_s9VzFy9Sq6&fp<T
z;Y*~}=)p(p1F?v%VtvV!S(uog5~Mc5R``y9C?A3$4x&f=lmS2V2Z#RF`st2Ia00KE
z;F@pGeM~d0A&LzX#$)~mQYWyk962}n;1gXGylU7bQq!Yf@z4$2=-lBlWlLi^U^QbJ
zyOl<3FZVwzU_`t(X_!nAO1F1MvEsSmfx|0b{ywS0Be#}eUl!i;zRuzSY39(&I6a}+
z;`2XdQ@oAy$>SelHQUP4^eEe;Z#3GEFIEdz^Y6W4@_mb(AlYH7SJa9z*o;d{>}nT2
zu5Hg0Olr+8uD1HZ_NkK#k{+aRraO1>XMVdSCh@3M7;hg7(N&>n=rl~0pdinVgnSOk
zt{oFgphHrtipKNhFQ#|ELaA@i5W_~^BK{oGD@p+;$UxaP7DmP`j60drxELWG^pQ+6
zgws3k;Wt(6mV2MZI{jkWVe;x%!y}j!!|w5=$Dk|?X$jE7BZIQkz%OV|ah;{Bi{w+s
z{(&|{T-12YLNf17Zl2@t!(3t^Yh5it^w@8Tb$fyA65p>d!G}g9=xT*&RIe2?wdEo$
z`Rp6wD#6CEXo)%ISA?cm@rY*T_T214rL!%Ig`hm%NGs_^#La#ndt2JgS%<rV5b}1B
zFtlBo#-q8e%0Thv<d;Rea9XKi^7R~9yH7_lwRFv{pUA=Qhn}1zd36#pdy}lC`ZM9_
zO)q{+4PhTC+=<bIHarU+UCw+g`G_^N*qQ_j1bx=<r=J$Bi0d`(5>I_)efBt>w!g-+
zp!=l|+XIQxUnN^S^IXFEWE%t@sM;2{xbVh;Ce$=lD2*r<L0=$?lmu3sq+-mi=^OQ3
z)6ckHH^?{*#h_cDCFM0?L;`-W@HY_+7+a-BN?&-VjAq^?r+#B3tv)tZk~h7p?rE~e
z(J8y+`kTL}&)!9~fEZ=7cP800XA-m9h~C&r_*&^`S@<dYh0YYjgW0dfs=Jw(m(ixE
z-i0rGgUz>3K;&P|L?$BiI*YV-9_{~Xyh7ZZC2O|z)$Zz7%w?v~NUn138<Xsr_&!<m
zxIT<zmlE>XPo`Svkh8xV`Q)lB{oQ7HkK$ocFh*3$xeF2bwp0g?EkIn*DtBL~&*=;K
z7l0SSW}drcU1~e~UD5n-hF1QBlP8mg4^xc0mocPp+P?VOS?^ekpV|4O^v+4N*I_1q
z=a(G9!!MM=!4I)!BzrfPl2d+i24ZgXzze^pnPg?sXns}v`SG!;co_#n*ETB6uSqTO
z(u__$@Z~rb?}?qSs)~fi4o;P$8oIc^%+>@q5|cr3U2FW_Pj`iC{H*~ETC~6KmtRg0
z!q_pd|2_|Phc0)&FQelz*Vr*1o`K#~>cz(sqiWmt&IarQv^x!#JI-HL1Q-8JFdZPt
ztv3_t>tcAd%-J7_AE)!k=im^(IW&S$^g7UFkpkaG#NcYCzvDrq)JWwkw}mv8u&j2&
zE~V&`f`L0kQ043?l%9@BxX{XSt4Qfg^Fd!|4|~izX#DiAuI&}b#Dm1vW2(^qkm$#C
zNhLL%0otne;@Ce5)r+y8wjiAIe50MJ#C)=uoOX9#F;I;9Wpw;T<h8INu%t;!edE&B
zp5T^u@*-v$z4uRFcPKpY)Rl?;^ZVKC55i#KOyrBo8JDRjGOhM_{@AM3R8Q(``k&VK
z@wA@2cVc|VeI-F$itl*9EyG)#VLo6NC0FC3l-N;pdmYz7BroiKBktnXX9w;nnD1;`
zh+Y5ut@t@8{hiXBp{|K*S$o3@n;pFD#rw0+&+MdDH$Q7*(pg&+)+lve?J)2ZU-sQZ
z{eHN8SYD%>75CvH@uGI)rH|p{-jcNBU0&^tb8pVP;b$aWY;0Wnrj<D)Nu+$-v;?sF
zDn_;}oN+pxBjul`7lCTnc;u@M<s`TEyxTo@BHEl`f#VDA#T1sLc6ruO;#McBAo63W
z%rhSrKamv*sc+av58pfe(YC<7^l4}+?jJ&d@04YH>+GC!M?2If2b_3)u!n_t)`Ibq
zUrpFgU8Yswp<mjYbyyM*wmO)AHp)_pj5j58B=48-dhFLM1!&VpwdULmHoLJlDwJmB
zg;rEYqF5?4?zCj&3B4wZ8*-=W=1bhy^*mp+h2viGmS5g!(BG?Mr#?<FtE1N951R>0
zV^$)VksPeo+kf@C-oBW1%+2fWmz1o~UKHB@C4D8)aNciba>(Qw{)*ZCSAMAEE~%z3
z+~6c@x82zHMwV`@J5BcH#*({XT)>0#$7WsX$Hc*6o!2UqaHo|XY~2#1@Nq(?^POqr
zB=?5=Lb#G9jb#FsVR#aFq2E{c{lX!%UF^b{^!*+O1O;P6$xX#d4zlJJ+m6gpr+EF%
z^i;c9T08w)e;;IAeycUbG5HDA9^@?gDKXQbRl>LxXy`8AGHAGk@>B%>j1YTVrMj6R
zc@a^J=Y~^O{ZfrAsuw|hNUC@8?v?aG$!6QU#?xG<N%Czo<{!+VPozA{>mBr*=bi<<
z3?vMc4XUa!it@(d2^GSvsHKj+lgUDBduZeH*3wpFl5{pJgtHhF|6NSUjopFepC_#&
z^<AF`7fYVr6t(ik={<6pFey5pbeh#R45pd&Rh3w55?>A7Ju;5Iy);1*i1m)idDLQa
zC`ip+bW2%q-qPc%<<=T(bh>}ig^nkK>tcBaUQ<-x0Ab3Nyiw`*n_KVfK@&%HWr)kO
z-!OZ2{(OGy)7Y=jg~g#(&>ab>FU;+BC&fZd$P!47YDw$AS_r5uim$<_d>*=B>c2{A
z7yupZg2%<ntKUcn6oC#lu9Mm>qaVmE;AKw3>9mv5pgw*N2OC{gL@?hDQt{da^|ba$
zRU}=x3X75~|Ki!zs<dIm3^q@}gIZ;l3DHMQ&S`s0Kw#1&$wI-no_9KxVp5+#44K`q
zj;rXC+ztL<k?L+f9&cT2a{r;?UfnE3rk%`HS#^Hh8RJV`uy2Ss*%co6b35jF8j<1a
z{@m-YQx>;!KNU?XlbqzijMmxhO&PYnhMf5Jnz!jgy4{7rkiKK*BO{X`a1~=qHH4C5
z-lsz|HCsIg?wRv&m5G!Pxo=m0{KxWYJcN)|JXZ<IEMuC&{^ib@)we&H2y0Y&Cr%>U
zq`6gX_^=&{;SaYT5h6<v0q`-Hc&F(6Y2BUx@Eyi`>^8SG8^BZjADR^#A{=O44P@Jt
zI5C>C3J^maAtIxMB-&ruv3Wif<q{rzhFE!6zUihxrC&8H$f5E2gg9xAyQ}=?)WJmx
zn7Pa*X8HnwW}T?YViDC@E6<(sxqBKP_7Ac;^q$nM!;SnHiOc>z541nc`B(Ic|KhFX
zO_6Z+cg6Y#b&w_z;j*wc73yLRI#Cc+o^B`Yquft4<mNo1m*-xBkN8H=npsE2;hC2B
z0~-!c9Kl~6%EjBjnq82n?tR?0+8XL}bv8DUIK#qa_x%Tf;Q}3(e$nZKsrNFMA>o!h
zNT5{o&GR73;NsKw&d&lvwj_7m`|Bc2j&xl6q`mH82ZWsHOrIgZb#dZWLRcGPRNSXY
z`Y1$*ruLYN`^Gd(ihB~{Cr>|eKMi3tnf+5?!zJ0I02Ks%%jeL;D#431drpqMZ$E?l
z3xG>ZP$c{V8*4i6m5`M=1v|v1^90J!4Vk+@vk4LMooxWzSONk4LZ@NC%6lLnWf@xB
zTntC1^H^4iqUy%hh0aZ+uBp59ok!JIsT|trELz7JZ;su^7QKJir3#?thvJU8O8%zy
zY7Upxb1+vP77Qc$JHK-90L2xr2>{J%EDtI1-2$ml67y#l|0V{qv7C-wmkuV^uNBoj
z8bkj5j93@?!NGh+6F<0rkvSU!bx7~fa@F7$tTN01_RBB&wX<S=;2|R@rDf}ODVMy?
zQ3_|j-oJ5qqceNiTWZKeW9VSped%n6{Ny!=C*TOW7~6Y==Ohdf6c;>|)Aug!G=3h5
z!`uBgwu(>*&rh0N7rNHxF}|>s|2}D)metd9(Z}8w-MCi^)7*k5Ns=fBlUutKsV8?1
z2F`8xeD0{)2w?LhcK7C=**sd~vXAGz)=U6&^7yA=A0!zNA{j6d`6VFf6zYVB8nvaN
zAWEmHU7xOv_b00+*m+~}RHkr}=QaM`XPBUVOsH(d>2Nb^xoR!s$A^@N0I>^6KSu8V
zCLr3W-_^ZcPET9Bze^FKOg!_#9#l{JTyFn8wHpn3+WHW{^hyo=H6fZbrAVy-o+1bB
zL0FcM1EPAmfrF;A99{kWXIEi|8We?|!?HjcV#_Nq)b;nJ+|TdcJ^Gew+}W6(4ZLKY
z<Z)lv`gE&R-g(pbO@wRR!#aVkFAeH@Nj_&SEO(a6-o`Axl7l`cb#pdNiFpm7OQ#{m
z{+<RNOMME7#pa}mJ~r4p+^n^3{n_uPB5|~d4~30bLD-YMtn(WOsf*Xmbz7q?^r<wj
zy}q9<oU%kjdTlI?+wPwBbM?LGGZ-ElMack`)x^yYP$ivgMtmI{gKWx1kl%<%%=(uT
zr?gAG@qvNg^R&o`^MsLA^>0c+22fO00t-?o36~7H;GE9@yuy~+d8B=4V@}+H)YqK<
zf@v)u_JIy^-hF4N0x2-b%>zKs-ooUOlkFaC?tq{?TvI<nCelRcb$|+9VG1!yG{F#=
zp-;?7macMrLFWYRpUIzDBtHd%6meZmdN*qR1~EWiD`nF34t==SQN$~5vz+OrrH0Ca
zv$v66{M+yXlqC2~Os_v=wD%ZJGX6-VLBK!+FPfZp?HJe$Efgoja--!a0Fk8OdO55e
zy{5aDCHL?`hbL;k=4eRnQ)GKGm|hPDxvF`wo(7WqCsCeY;}gq5Rvd51oz++FBTBul
znw6YvF7h9E!&E+gP^(o<U}W>tX-am^rzCr&Z#Ccxy6G(K_UhGG+wJ*zQ3Qyt7yZ1_
z*k0B1)V*?>6klL3n&aB>+@D%><#kiN@<<R`?C<w@Q|DE!*`sNoa-}=kZbu;pA<(2q
z@bWed$YZ6DM%$<+H8E45obaTRu5695B)Rc4J=*2TUQ$>0uxv)I<0u3k(9@h1lLg#^
z$EGYbF+&@${x@puyeq`CW{wa(D4z2{h9DN#MMz&*9Qx!!TBc<h*t5k$fTEEe)X`of
zNursB#|wqj9rxXML1dunv>TITEppZ>pTf!Q`gknP6Gp##?AWXO(Wi-t`n{E3(ANId
zg$%FRSg%cSOBfK35^i_c%uYkvY<|;M_$2x#vhI^<n8Fx-Mw6wd0kgVZ7CMaM^MgJx
z2Aj`(O7Ay`f~c0ksrw-2Y$#H-!K>#UEgd#bV6*Oujs7l*dj44}GRn6-BpOJ{4lS%=
zV|E*?(HEZg%g~7Ava5Oo(s!!0B<4?iy*KXt6=)lk2Whh%x0_wxyPmrjJJugMR(lu#
z6IA@uSjhwk-4tYLr)n|6Z}9t$@ssb+^tP8A*m37OEu0V&eDN17Vtko`L3TQ}deF~e
zy<99oC!eIRjDWw>hUJf2ev#oAC8GjuVhhc#rWqRE<8n`(37nQ}`)+~$k{M&4@8R)6
zK-=YMzweE}=Y=`q&WexDZo^Q2ruRY&Sf>`prvG69uZS1D^V`WTlBXwL3I924IIS-d
zOe<lvs~d~7(RqZ7@DyAO<L4Q=^6A5;I}(u3v0%(&-X*(-&E%UbsUem=M9A3O`L42m
zGvM*-!V;&-6s8m2GF00U=!YlcU8o9t1^-1rdrH+y%A8Q`5g$Lga?&zo>N5)krsa-!
zU{j@sbXsI24xf=tquH@rU(xPbPIIl{ai7SRYDcUK(wXR@*PbP!gW6}o>kZAtl;J`(
znXmY4<7(kyo2%#3@|Uq8@O0zW4=O*6Ix+M+hl@7QmG<8Yp(}n9ft_74Pd@1S_6ds+
zDwEO3-eT!pLOJDydGI`n%dy#Q_bT#r?w|?Nhs=%A@=j|+vmU2{J^6ON*I#IZ;DcG%
zZU8Q;i}sWa&B)VdD=_M)QEpik9IV_OwXsppYpGRfx|qHt+`FY5Ie-2NAKYB>wX;Gv
z1~e%nPgP4gs-T}nD~=AQoAL7G8{!N+thBa9IMX^qa63IV3up+FE4wTh%d1MI*?DF$
zogf37oqNvh^;;+T23dqBGegjNt<i35A`nA7Da<B)upISBIaUT*H(C`fatg(q!$s)7
zf=Z_tOf-wzoTo`%`5a~Utot*G<G-~vp3TPJ&xQpI81a3NFz~~qBcHv)PYZun>x~-9
zZrz%HfVj@hAK^cpajEfwjP6U(4&z3jVi{<XcWX8aGkW7?X{h6`>42Us$Xa=lNBO8m
zXo7%6kbZ;v@RXPIu(IAXh$lVuo-AtDIy<ge`@>98@n#O^ju)Uej-Zg%?KGGo*5WX9
zPx;nnF!qw=oUi9M-f94WJX6>@*0$Vhd)6Y&8+s{+81<Y<jS2Z!z#q-gWhRCm#TAis
zEk_+3_USH(6wNX$RkuZa#H%Lx!F<wm!iBkyX!mGP+$cu={EqzG{7|v9ZrpLdr{l<C
zi_eL$r*QSl+%@IU;bUDfPuD2I^@fMQ_NFUPRIFWna_yEj{g3&4>=%t&xAh_0?QEoU
zvQSD*iUn+<_EVV_gP)Uq)|9%CE^f7N993UFZG0bIwa?xdT3L8{a<=#M(>Js6<mbl{
zhx+0jVhnW;XDcTDI5cVcQc8QD|AEs?ygZ&O+x5OreRIv*JySV)X4gmB;B{;)hN&6l
zmyg2JwCh1}51xt`cesGkDH=4SJn6;?##pJ+m7Y3c*e`iHja>=pHoAI*0Y~PKMb8|x
zN9s=cj43wF$!E3u&Q*0^Ky=VRJ1xxo;TVXxtSF5yQ-ufIOq!jzPk7*-9uiqQHG8f7
zWVyB+rbHnau8$E4<NtjjEycxk7W+dvMG&m=Q8fux-4iz+?U9uy`^%Lj-Q?khYwj$|
zQ8oN0IpxVuMef{>H9(k)E*l2*9CMHuYvd=R3e;)r>aIm+L@k6jEp5AESc_?!M1)Ta
zf5o}B)mq#)ewZ}J8#}y7ZqyX^%y3Z2gNJuDO^Yy$d%hfMW+Pg>&|S_>2)NTE?^nAm
z8vA}WYjpPFzUeM%7x3}6sL|g%3(c6LKW#vTR_$0sw(Ho>{dXcVA1tydSJ{!$R^qT*
zR@o8xO^?^-=Ew0Op|AUY)b2-r`6d1qHAXJ))N-eu^h<ZBrtas@d*AoCa-DTw{n*RF
z_A>Pu$x_bi$L8EYgv0+?9pHb?Nhzv7nZ#5dqzBx2EUiRX_j>m=)mEO=(1FM^=lHIk
zj{P{G6feEfP>4pB98fJ<HUiz;F}~2D`fmvbs`xPcb&vQ+t(qkY2Ibs}V_SPq-SgNY
z4Qy^=g-72BEyoY4)_0|3LUxeX)HF-IOFt7kME8Wi*SiQvzqddG4ehOF82W)LZROKa
z#eB}gk0ueKnY?W!R){}BC5J@#<Hgl|Nx0s#P#mmtYZ-%0am57>X(I2GsM2}DRDShJ
zVn!v?3#b!*($nE<g9t5OX0LcuJO#I-gf6dHgz4;?ku~r@$E*p*t3@8HEBQQ#klfgF
zyDTB@u<rK~$-G{h);cS`Ew~PglswnoANa!6CfVKaa3_J-XV-I`ZU48E0hO=&<d^-*
zEN*6{n`_Da&z`&?n%4)P`Rmprg*)t~P-;Fo>j$AVw*)WC{kGmKpz-v=$jqCn1xIYO
zETlY&3BAOj)p*ZbOnR8*gAwZE$j+&NUK#|%C{sS3?MXn^fnz)^A)qpz=`&i$jZ&5F
zDh=LvB^qu95Xs1zT=5xzHJ=qikE|55BRq<@Sz~TZh!yA8K$eftoR#_~H7ho^4)x+%
z3d_?QDl7XiAk@mVk;_|Xud`PebGdb#2eRmTQ#@stD(n+{`WQ=0bSaBjCjU1Bk97=2
zX>8pxI>ZS4S`$7Hht?c8$_8<ow>O2g1-)UVZs`)Drzrh8=1|&;Al5-73NKbv`QQZN
zAJSKJz9vJbD0oVD^_j_sf$G8(+G?c@9a2S5TlwB=CI06^FxfU8Z}sIDt(6X%R#o5A
z#mWBb@tCw3!R>dadKC7)Qx^`Cob2EJrs&!;_q%PxbVt4v>>V)s)gJ^cVa#`Gu=|ov
zZ6<>-5-a&DXw?G-<e0kTZIKD!p92qOnNC1K#!yjF)th_m$8f3J^Zri_qc$0+Tlv)b
zZ!rg#y*bEXXWm!oYVP%42f2B%x|EUj{?;zOS_|1(6MV32DHrTW%PYLxZLZG`-0<fe
zVDY$#fPp*id@wzu>TkifdW$Qi*6w|9ckmUa{IUhMW_%Lw4``zfGLo{9_CUBw(Xl7<
z$^(R)*olsTiO&+c?d@lL%KB0%+WUnnr9X;dBxNGKJJ#q`Gum2plc7yJ!)RL7>nA&!
z0sB=RGn>`$BsOhPdCsy>CD$?0uuQOgOuciqraJWtpSjwd<B}<+3Mw7zHu~p6;;#03
z-2Up*bo}tWlHIhhTpT-Xh_j`RGxT-(@4X+X0GwV>mqtX&l_csqyYmofkez<1GHd!c
zK#~iuA<lx|YM=LWEPn9#>algdP04ZX@lfGc8kuzU*JIaW?*w3!*N^R$m&avr_XY}q
zTbYQ{@5NHsj@{p>G_1t~Cl18eZ)_iH7~}{ntH<ISCxnm+HizX!-aJP_$nLD{qztBA
zkre>t=DBX6$Id@o(t)0M-I&(Y+$=(n{Fp(`nl})a@Evydm#^Ha4^jNghuN)oFsRDU
z$8Wu1ubCKs<$Gr{l&{FnM}XN$ZX)0NHlo|2<sY8=>3l5Vh3z8kRh@to3p=C3`>m2e
z`u(oC*?YVVmqTu|{j04Mw^vCAZ_=(ld77-J8Bl{13@3aW-=eM5=Qx~S>RS8YuYE_T
zkAt_eulGSbsCi!1l1{zHSJHraj@$kue2R4i7m*$t@@gqE1oCjGC-wacW+P;;9tZ*d
z&@6u-^RfE-lkzwC>HJLzFBsStYRH;x{2DCZ<tJsSi_Obi>dfr2F=O!Wc0j4OyE5@A
zv8cFAmQxAom;g2EZ)ES^j*UK4y}v@-6O_9@>SS$&t)?H_N>2FV=*ER~EW19L>Hr~I
z>K07A;x_JllHcuz#?k0Ecr>3uw2;snjN#O<@(ek>11B~bYFqinZS~G;edsbMyyJ#n
zGDnw;0%KY$KWq+Z;fjz7UoO&BWMA)LTDb@4OI7qyw^8&S*vQ?Pkpq#;9kVzmm-`Tk
zu8Ju;2AVWa^PWlb0IkK3#BE&6RZngf3!RK7dF_J}HXGn}RTl>$e<@f(DkW}<;M*Om
zape-*uC8s4w^#0UyED3NmoAf1vz4nmW)kg0KTS$;82A|ENDA3-VU$3#oWFhcrJ8wy
z74&u_CvlUhUr?UHHpM0KE&V+8CH`xO#`weZG1JeZ`;0Q08_(HvQG5et@J9`B<tFe}
zv+`GanSwpOhsNGavC$>v0;>jSE0g*y-3cYASorCNfu|1=_k9^*sa=EOa5TQg=<b(;
zlEvdB{r63{oYu3^9;tOJvL76pM*<|JG-fns#I8wevr9I)rQA%6=H5W$#m1{PEYK2s
zlW%Smhm0c<{LlEl$};d9&p40qgaT^iP0);(o9%0yFZI4eU&idgyrP~V&As)kv?n!1
zkWl$<H129{#3!ay_k;LpO?afI5eVef{&xEK28u_q(cJw+M7-hsG`YjE8I9~g9b}Km
z`OL^+Z+17#tWj7z^>VG><S<;A1m%b1Q;+cLw`NH~N2@T`3RaXr*#aaBpEA>C;>Fm<
z2ZY4wL|r(>Pl*oN9-6Tyy%Dp*UkPF-d%WB3HIgC2yFx&mZ(mG&tQ)^}B<k+h(T<kP
zP_*YR^$3^5llp3ZfR_r_M==kN{fcM86y&dLE;FLryWaJmzPsb%I$;(^nrnSs8doy8
zjC(~fjvMw)XA#QFF>8{}*>-7*{{BJ#bnUc!Jv_W2@(~{eEv2qjrGoR&I)l$A^Q2~-
z<yEC=&k}IUYUSIZF*jl^B&AF~b(ob!=w|)F6WJHXE>lkHF?30RQqAAFkF}zV3)@b)
z_U4<8njiFwTcOr8C#sV}VnCG%1^cC*lPnbda@lcq9klK+XZc+0xi#<lP>-j%3$LUi
zUFAPx9k~7w*4hj-LyH$%)Ovfxj&9-qv5{;uU$iSK!`xfPo%$th#_XUif0R`#yKqnt
zWz@0dL%;+XtwS}ymtYc<gzHk*+l6aRffZWMYuUBFrzv%Joq%uiXK&XU+Z~zo<AEEy
zgDeSJV_Uof)oIqqStnLJj&c!9(_PC|=?VM2+0zE$@oj5ZKRcF1d7(yePo0nceorC4
zlGORqP{AmxpI3^@s6vbC3xSGSb)QfnV!|!2Ji$fs#$Lo!;Em<JpoT7r5&Sq}Xw<*-
ze%HvilZEiiI(w-&b}eEY?OjglZalcjbRxCiJr#N2L`U%uyz1Cr?o|H~yLYBZA2Yqq
z?u+ocPb}BX6CWuRAFR+UQ}BlTbu{kX_EZQRT9D6=u8D+GF42h0#S~VzH5*i4Krzvv
zh-K8U1Ot@sG>EAtK_FWOH7=ls{`DHpi_S6bJxX*_8?YHLQX?Z^{w23Uo7rLHf|i@4
z;HS-g3QqqcLoQZ>N^aoey7J6X{V$kx{C&tzR5{$nw6cf4JJ4x`^aM8Ug`1t*?ca2{
zTc=*Nk(<}W%VsP((FFD$)o^gt&Ou&C!2yYl1e$&CKb5TT3rBi}&0j2Pi9a~rVr}-9
z>MhmD-skmuzB-b8Mf{@ahx%MpTt%BhMyv)A+snR7I!lVWpC_c2FwzBh2P4I_LZasu
z*}8>yb$-*oE3BzoWNZMRaL>=m6|O6nXP@+tL~0~?i-$BUE5$_zGu1|-oCIl^p7{^q
z7yjQ$8Cfq~+ynGaha5{HbtogGQ$py!T@p6K>yQ)<6(EFG_PWbi7{Y}cxbC?H@msSN
zUDyF5>;~BL_WR&(Q2xbQh$qHzd?`Ct3{g80xU4eT7m^xkK1e18Hd0lh4m)U2?+-4&
zP`j=}+{V@aVF7FZMV^k=M(9_{Kpc5=ig)^Q604z0DSn&qS<1RadD+}!q_=InalgF)
zz08a2dXR>HS;AS6$@1~gnxXplkAm#>a<R(ymS2_f%4XVQ%I8e-uY7cWeUuGvn+Czu
zcTZjvg3T>|o~!b0=DLjH!0g1`uExTTKb)M<#c)42VDeIjdZ0sk^2hGsu3XC^{WzOk
z|E5UK<ul7?bu8YLoxf>fA-lhC164O6;5JioH4}{q)ZXk-rZBGNGsKhlqef7>6G%9K
zC7@+rr_Cn$jMqgO7pV#&zuJ%AQsl^z?}b8mK0g5T=I_47<-o{e&9mM?HI|z+pcY+D
z`lMRItP!8bmWp;h7)n<d;Z^-i;XB{#ml2&OCYW<yO)&~!!jgP7Zv6a%qfrLW62_7W
z5qZy}|F|*c=Nsnqwf~eVtwwS4O?anbn<#P45~RF6^t|@l{tB1#0qEa>pQwqA%-K_Y
z!LfvhB^UD>d$*EnN^%h=;o@4K%w&%-en8Cjp(=5Rm{skYpG-dZiRHxyEMO=^hE<}^
zE)yoJc_D}fCsfFL%5!2X1zxC&lhb0q#Gw^NH+KvhyCxdf?|A~oaQ+Rq_cF08f(J~5
zJ3QBG+}N}bo&5-^L${Yx<9xn}Z<v{3#Wxz~>rRyFDFWsuZHn~yal9la<Bg0v2!!6Y
zU}c4@AK3f@ej3F6$juVGn4D;(2;*NX+(gK*y(i>0R#d1`iv=E3sOdqC(0uKb>GYd9
zOT+kZo9!W}DVu|Qv`50<_`OkF9JRwlFF#>(ascBLBNYXqg#Fo|;8lPg9Z<=t_>*K(
zjq-Phoic*ms4DBKNk)-pTF%GS{LE8E)2ZKqn!{@S-eLX;u!?Vt+;^)Eewv?Lmh7J3
z7J^5JfBdE9VTALYuW)b7x^sRRg)_^dWz!3BxCX=TKmJzvA7*B=dNH4xJ=L;EkW3;}
zVX+J-%+vLmr7%!kJ<E?SFYekm$dt<A)dtonOqMs7q-?*3kG8`?xmiS`=fus)|JDz@
z;=?X{;?%+k`+{()GmQgP@NdMxOgloL3=R0!U2c{3L!I}Z6YlAx@V+noL}2akSQYkw
zf*5#v-NWU<fv{kT!U0rRJL3}hil<}XP5_C*q*_)46t61~)eL*B;E4SiQmB2HZ456O
zsbEVsx1wK^AHhD3lJh3|u-P5HuBX|JvnOANF7OP0I;F~(NkhB-wV;9n``Nhv_x;$h
z?r42U<SnRO=l;zf`zV6QGvv{?*D5B=kbApKm&WOza=pN0W+RedxRZ1$T9YR62Tp3M
zqfxfu-p+!D7A$DWAjoBVI4ug$ds-nk)-4(ORb5kGs7~Cut7(2CZT8{y*rl;y(EhLh
zq`rOB+-y+Kt>el-kd;%x!*|HJ=+$l=sg1qo)Rcdo7;*a2oj%W2)7RItT)P>FQyq&w
zX}5oLsvF%ZJ!re*DynnT3YmJ3RDLHE3m1Py@pIF_-w~~oWI%#uliMQHE&PWqg(Q96
z1(!G8Vfc0S3#G|&_oJUx9NXMx5e~+uPFxw>%jYAIfA4M%Tj+xoKJ<f3DidpdVNuoH
zr0fhE5*eC;7OivzP~di6+>R})DR#lyNnhlYs16v$h7u|`q%gt<Qww4w3jPVxWgcTq
zRPHlnDltw}7gChrvsOlrf(Z@kwO(k1w(1)gd)ZT|2k7fIZu*Dse9V;)Wd)^uVw~0-
zk())0KFI3wMs=8EWyAD_kMzQEkzyHsyPUZ!b@KR(H3O&!t;hBpHXD6cuYa}K{1t0&
zet+fEHLZil@%?Pky!UsW_c$xzgK>sF?h^=fifxs}AN!$VL+4dTJa)evA~$^YLA`@O
zIl#u8UmTnRTiWkDHX%Vb<;1nq1)g6n7sXtRrrUOiC<oqe<<oaxj%^wxe~JA?^kHf~
z-C%uLz^#Tl{wYU*iBrWVJo|Y%0s-vXnCG{TfI1yoqfpEnK(+J@g{NwPq~8RN)=VjZ
zqv?Y|f+zAD7wKX+jl$>-W=%dTlN5!8t|*pxr`bqA-sJm;imlU3i60%weX0`IY`X@H
zb$~!-toC==Q?XrwyMOEKScT2pPPq;077-6JuTXF6BdJrV8>zG8sjl!+KW$6*l2jwR
ziZ?lTIhg!f%KqkQ*B-MI@0p)oP+9ox?MM37xj0-<UTPBGowcMFD3Qb+v8`!VuI)!X
z^L=_36Hdb(KKIQE->_@pg51*g?5yxxM(+xhciT(8#nJ{8ch<!Bl<ds@)fUcwlhvVX
zXTgRFlua3l8}q`9bROd>pzN$Fh{Oq-<o<O19gza=j{u6t@wVvLwxXWjA*@ivGeVdp
z**Cba^INo#3Ws^0&IkkMcE$h1fWQOb-t2#cwL3L;F+$@e=H#?Nc9V&RBQZdfNzBhV
zC_!$FobON(z<u4hYe5eC4gI>4<p_-Z;4lV_c*N$!Q03k!V1QlH8MFBnf0#>3|I~4$
z5v_k6Q}BMXByrA&9|%ia@=MGO1IYSG$^`qFAgluVuTSAqlh5&HsZQOL0OUyY(5R?!
zfS+i;toarPglu;XU;3=6>YoWh=3uJfa%T6AA#WLh^Dp<mjWoJSH<N@_BRQ_)Lu;=t
zG`WWHLM<8>S*N@gLfC`abW_C8_RNAuTq{sn6~W#W*AH_K+Mcz$?MM!i!H?us>T28H
zHQEn9s|hQ6J=&P-J+(m8l0VZ<`s)*X_5qDs2h>$tzYh^{4@{L}{FstQFHNYNq~g18
z<_T({0&QX*u)e_^&3_c4VCfP$Nr`kIi*goxW1L7*hv<h$FHFld1)`K!-t}5Yp5MXs
z0Miq%?p;B9P_3A7Y}tXlGTM)nA}864F&RgGoK|Lq)OtS&35Azp^Q){eGT-fR%UU;S
z767A|N659`v&v$j_pLs*QR{M#b3?V+<SYDrY?cWS>Tg%;#?sT0!bbmU16H<qs)c1P
znWd^ndNR2#nOEaNyAWlbJKdxMCC6q55U*SsWgv)KFr&0d@fscK2!^~&z|mAKdHU$!
zqGGu8{<;1ZYpr_HXFjJ56t$bH5&Zyff^eS6fI|<I8%w|W9S*%nSUkIC*gf4$^hmQ`
z6kA>wxM+|vE*^Xw>C=1^>=ITW%n!_)?K~ewfbso%qc0j=^Z08*#_YLUF}EvWYIv%m
zi-E2awD!>}`muO9-y5^a&PD3(W#hVisyweY(}wmw!nEF#!*P9q4eq3^HTjZ}E4GJ)
zb*HRyvbRHQHaF$swMfV@Q9BIp6*$5-gaaxdj11`Q<}&2hcMTs*cYw8DHtX)rB4_gf
zCLjy-G$nP%`{po>jN<q+SD{u-%G>>O5fMT_G3{a`>+Pitcf=fX)Ilxa6Ha{JftH<B
z`4&2zsgOi{pd6ia*H7nKAx~j1Vw6=H5wAn3<wSOwQRGYv#Hx^P;O6?h<u0lK4VDVW
zj3QrNHR6p+Hik%M3`Wj$c!{2db>TYZctN~Y=+Pyviaz{JtsZ?Zm2tAcD|jhtV{K)v
z9`<hB$YfH&V#cwo$vDIA!bpDA{dmH9idzbJp2%?>r;BJ*73zJFY!i1wP&Mne7{2_8
zquu(`X{VbM2(e;{NjJeKbTcBhVDa+zUGI2zoN%NGWJeq8aXT?pDlQx}%m$)sTt|)V
z66YRO|6FYEubHcbyuYGHg-0pAS;QzH2y5*~E8<ntHSbzH426s%N$w(TNKKP}*hHvH
zCm{opZJN?Q)e8**oou!wI2FII#UM#j+$p^Hkow8Rm<06e(hs7AjrWk^zwPL4a9W|B
zTG{`UR7ZoCMU!u(`vJyw{<e&txKW+&<^Z2qh+4+w`fHwC-VIk5Z*hF;gt=dW^^9;#
zDr6p)ptwNBC6C`vi#s21gXLX(5RwcJA)Fg@s>zZ+XntTVZr&$kJ}zkm+?ulyn+C#T
zGUH_0(ZYz?W{Sg?qY@ekGLq?ibw>GREnbE!$DV+}q}4RWElc!)rwJ8>A4n_oZWEH$
zEo=3_;(Fkg<?Yr{H<`W{I?U8_&usD~Qf4jiBQi#ry&JWCq+G35ElGag+sk}95*apj
zf*NoW>`qz?dj3x%+_4*_3r7;}sSs85q)Lj5hzeWMxheG76qIXNS%8MwQd~4d4^g{y
z?X~tJ+8L%1>sKH&2yJ7F_mK>8gjnWE1aOTSG<NkZgRXxp-V!8@6ITY0Pq{nkLmP~e
z`ab&GrV9ikWF(x~6lEOvl{A@CNk4qOrn-F%>=qOEfA{A@05jgr8hQyXJOv=4j%@le
z`ngbw6E-2lzkxTc$_^%TC;lW<|5(>j98LBCxbH7krf!Mi(p6@7$*}lppI+G{^(jT$
zhc2gmxA{aK(V!3ih<B3p7g8+BRw@}q47$gUh#OpNpXq7w!HotYr!uxzn1{&{iOns>
z4>ZgyOQkY=je4v|CCO}=NXZnUPwUlhI_ac!l)!1k^4g%fT>mZLl!WS?y;>2*zl#)p
za(Azd*9V^8N1BN`$7l^rLBfk2XLEJ1xCEBYjZ<zEB6|wXapU-7GvDG4!+9X`bTR%L
z3s5;7N?GLHoOPbWuckln9wb*1qfw<FWS-!aaeM~(>7)CN?zJTwv#|Hvd%5e!t`z*~
zolEEm=pRi$hObwiEZ3dBzr6oahOG-2XBZx-)({4W7y*9ggAs*AVVv>v!8Q*ldn);%
zO^nfF{1~#=gPFgoRHP5yHkq_&=-N_Y3sxa#JUGd^tuX9G>ShQ5BA%`vExQ{f%QhCV
zJ!#wo3Z$kg<%WhO>BW$f#yRRwS8zgcuY+pEb}6DfK^pPn=@jE%eT$QU+%QJz{eQ2G
z1>b;ae}^vs6+PP@a{?^&Pcs4hQGo&C5AkQDmIw}{c5y{SL82CAWB^r+G@ogUssNQs
z-qrR3X(}3`N)&@b#TQhgpK4SqY`tv+EnWK&ibutV`Q@wZuptiQ&INM9rbdcW!>i>$
zS&))YCeP;|Va@b}wCdMIVOtAiQCtkHx!2g7O=~RMX3|A=!-hNh{``Axj4ltp@>k}V
zFuKCoJSRn`r###4kP<QXnm3E}cs^Ff@#%a*Z<c`|)Yb5@sffo*`CSm-k=k`Q;^H>_
zjBJ2ZWo-Jez|&1)JHJh3@)h=2_SLbQEYmG{@3v|!n|x1*bFYm0kD8KNMW(Q>%x|kB
znxoK(_W#Qa<?Ke$kI+`gMw`-m8o%E%0m|E%Np?DRGS<r*uM#QI=3HJIb}|H>A64GM
zjNXp*l1~MPL)4Zkt#&Rpi^x)$^;Y?43HNgS&Q0*wPvz&y_sY)(mF{6tW6-2P%=g|Q
z<?qH-V33A9`vBMLBp>@#XXumymYf#fjVFx$5Ryr4hQ;&L&7CqBS7&7ou#PblhzW1M
zU?{2=z;a+z%nTTYCEG;l{)Yt|dyr;F5wpQ#KQ^r%bY=de6xNQ^y54ZwurZYiUd@o?
z%hdT5sV<dnv$ZtQUfYgvjgqNT_eAkmya}IM(XeV|n5$1)Ar2)<lq7y!vMlvQlP2>$
z!M%0eKt{=?ds>$MoBg8}gz~{SXlia=-*nUm28R20-sAp9zbj;rROd&qVUYfN>2Z<5
zYebufaE>d~6k~yXf`-!OP?Wa!(cYEXE*plnu+9o0&6QnJp6}j6_APL^C-=Y_a$W%b
z9;J7F$K1ibcF%j&m?2C4=|by1!cXs~%Bv)F^#JV8zefc^T+xPpm`R;IN&^{eFS~$i
zRKOeJY`A%ZFeSA-_^OJE>eMAuCG>~d?=6!~;WH-RnpbAoz$zp}j(egF4NF`hrS+hM
zfn+H<;TrI^@)OZ`q-79>*|+%_jv(rh<`qi`i!m7;+>zQ2ZzC&(vvAx`GG9Nwzngge
zKr-oLk!(?g=dC3=Y`BLpF*f@DUbKPt(yax)yABJ+a4WyCwc-2l>#d!x#xmQUzkA_}
z*eoE9khs)5=3_WZk04-#=&Dm0hj{-J#H}Bu&He`*>9oct#|9STK7mVEHQjH}#v&nF
z;is6V2<rVg)YDe3V6q3mAH+cNhoLu31`GrhPYdCVHWWNB6{LSwP*+YncH{o(bQj|5
z#d2(lkDmD?!v<v}zg6p|Ltn4$URx?X4w&xz;}35WeJ7`j5=kR^Iw!K09suR)d=8BZ
zm6vE=oZwl~Ii6FyO|&VbYv(uluNOyGYf-yKI{Trp3-*a^L~r-SlWn?+Z*gDLik$di
z*0w}A)-#8Fj+|C{^S!U?aPvGxNs9h4NV9Wnl_>v5!25UF&ch_IbcOdL?OKqr@yZ%A
zh&G;?47AFsr?TsD-dBcgdD9*^qjz2N${lw&7Vog#>%7K^5UD?L<oKr5M~P4dM#U}w
z83Q-A*Z_HmJLg1{qwF!XBpSxN#fBpl4UD+K=k<I#F2kGb)S4)q*etINqfpwh@FwH8
zjn-lIE(IxQrBcsPk(ImS`PO=+PAo5*Qaun1vuLVyOMXUiQq%~<VA*I$tT$~aCS)$a
z<pt~Fhko)kd~5C}dP=caFPX-&bb4M48P0_y&t#ZF`;Ui_5{{5)-9WlIzUx^?ni>9o
zt{{T1#p;mufUlN1d0KU7kMqwDz)e=3m7JTcZTMR<sGR&e^Ff~!)x4cE&|g)RKimC(
zCLnq!VLYoJ+90XfypV%=?w1+}f&zz+B*lea`6a;22S0IVf3;PEWX`~%+KQFR?g!c?
zGyNV(*jXK@$HA1FS|7Ar%>Gk$?6}xYT`TH`sg%k5c<Ix^Fnd?+n9ZAk)jPb?{^DC@
z-6J%aAq@6nvi!Gw$o<3Gx1Y+(x(#L~{bKJ)Ys_DCznHxv55<ggdmAuq<bEUW;ZJ~2
zmxUxUKE(e3OHixZ0D=;%k+E>sQU1h~?mYSaANHygu)^M<iqEk4I*O%TeHH1ITDWBR
zZ%~0aL@W8IFq~rXJRR{K&h+;hFUpy88X7z5qLs|Rk`O<bSk=Le6>oL&-}J%VjsBQ@
zN*2{N`B--jBtYx3E=2w$xCeRqOYMw5=JS=awU1@%Ap7+1OhwGyul!*`NP-CHoCHWe
z9O<a$L57ziKvY>wlPsx^lFwpfl`RiPW{BLA+gk{UuW-ZJhqd*GcV2G1``q8L^B?l(
zw>Px$C7rmc#K}fRU?S)^Qe)vE`<8F<E3E<wMUnf{uwc-$Of|}M<gC-Q^>kj7Dn^O)
za<s@t2#sTA!oT@7pcDEoDZ|X##Ha&r#vFmfwvwGezd#4Li+u1oFxsbfz_vUmrflg4
z_ce_w2@)oGAVkbra2k*k9JMt|(efu=X+q0o7gFnNdsvujcnQgPto7!+sP3Q(W4XVN
z1_952Sai|Liy?;oyTe&ZWG*#5hM0yN^Xo2g)9+sw7!$f^X;LbQ+G~pS64eil6M2HX
z7+-r@vU692HO+Ee>l^-Av2LhYr4FlGA5lmf4sZNdHs6F*`d2bgEy6q(d7Yx(ayr=M
zsMZ|~65@DT0TgQ#Fb^f$nplE!{vvFWbO-%i$4D-W`8xBraiFh(B>wgO`FK5!S9C8<
z=WJvGY&gy(!^nRMjFXAvgbw2weppBeAd3Cz$=z@RA&JB#`C3E<q3**)k~0uRL2E}5
z8?Q#nw)`MulQ?YDBY$a8=eoG*F}ZP{>G#SkVH|)eE47U4w$toI*$s(l7Jzx&QhT42
zFSHt$Z7GJilv~j^(^@0awOl=^5LARj#ht&-6MV=b9Y}`UDyBV(0B!eKsJ{{7JG6p|
zSPMG%X{0y4y#GpS-z8ZX;^IrH>!Bh01r9H<^9k2LmsaorHsHm;+_BYlZ@H_?R9Nio
z<A%k6j}L5>I_R8&9R5*5i)<TugB))FhL^qFsrh3rFdhIOt-{ltZli2rV)dni)wmxB
zwHBjz0aeF-y2LsNg*z=nXn``Dre89)*`(8%A>H4l@3HRQd>v_^^v2(l&ynvN7oZTz
zjMcZU8QTb!&3L>r3K>wt6Dm21=%qFlWW4wf$)i7${^Y4gdcsPRXu9>&%v<YPDKbh(
z;f^MZubCSM+t&5Qg#0nD%o83&pXYb`T081-_07}Xtyf7I{SMc$Xm4UcMxaOmrR8Pt
znp=&Vk!KcO*se<)qgLx<Q5;j4#AL-|selr*aWPD|%7abMs;?hCwM9zBT#%~bZ)0Bw
zb7jSdypUyIcbeRf{Z|97-H=?Ku_-^CZ0TZat+G2M<?>y6klLU&YkAXW_)zqwIo5yU
z8~p%l$^ldc_!y#>97&*jp9?0EUPDEOgn@0!{QSw3JxxkWupF8b(%xk*)|eMk-}ewg
z4m{X>c!BGLL;U2L?59pvnB5RSL2XUTcWh)rF%F<6E-M~uGQiu>IPbZcV(|K-3)_T<
zX^p*SpIn-sI!z-V$sA%pBmrlb>SVY_B}~<tiucaXw^P_@KYUW}Ht*2V4?8vL*d5{8
zR{|DJ3*o}Ev^`q6HxA_ina%!+2B93g?Vyc*yTsm4Gc32Fz#exM+;0i~V*Su37Rh1v
z<~{HjjATv-7kngsHjMz_0l_tesBu3p4Pm(p-z(M3tB_@ue?pBjUpxWsfRPFP*-Z7S
zoSWqYsyr`>b-weH2LcRH07cX?7t|*jz>(f2tnhjVk)q8CPx!6^a4dBkfn)SI|5yM4
zP}8Pm!lFTQLetVS(&U_iPO*to)bEiR7n=$$LryXZFyF&)XoC})|3vr&c(+&1JNEA`
zOjdF9wIdb_K~R5^;4N31L9#HeRR@tE<wfm>c1h=P)2=k<Q9FZMS3~`wOl)m0m8M?w
z6Hlp<qSb=sv&G2W>U=$!+kZ(Bx26el^bUl`ns@-IG{NU`DdMsSW4tQJR3MiL3ZZAv
z<)Nu<GKFwpz0`LzoaWi!4@U+Onj*%XXj5*wlW`mfK@vB~+Q>`}iB&cYDRx5+1Scl%
z0p@<{);`$5=Fd3*n|d1TF<^{+*Z9l!ZdRnHW6~TWK2x2p*0T9A(z>3ZcgL9?6q&MU
z8a`S&DHy&I_4a*)8CDd>rNGP3nTDlH?O}(5MKZ;_6iYMeLA>C>Iqm8*QkczE8AnWo
z`amUM!8&YzN5&IBEQvZ$P#;}bJSOs)GF>R|8>m)q7k?M-Y8U2$qV~c-gNtT|@vF^B
zqrb!@Z`6B96@#-)WyqD&2nY-UAqspl@6wDzYGR>>xcS^sguz5={dhXu`IqC`Np5H*
zms%8)?kN5MrL2lw-QW{6ZnjW1Y^87+oR}?M1=NFZmlgh^ZpTV#B5xX577mCO2219L
z=%m3M{j^!Zg4}~GZIH>sve5~Izu1kTFp?~A{3wsadnRqGULkm4mUrpAnBcC3F(z>D
z%ueFXV#vpdSDRQOJex!XA1k0Wd*hL8V103E^pt&qp<LaqP2+f18)HKVVlUm&{_?rz
zA88sr<8pc5cNtu56MxC7M!2RIGp<`Txs|=Kg+=)}rD~!Yh8w-y_rZi0B6`AO<Dy==
zQCwZ)#PH+E|Hsr{hDG&$@Bi@3Fn}W<2uPO!NcSKiU;xr6(lszNLrd2Hiqaz8DBayH
z-AFe`cX#>U^ZEYX_i-QlF$bH?wXeOdbDisT&TFVQCjW1?)2?(-fG_}xkD7G`!{9GK
zsXK$vJg>Zeit&NntbtGPT_kYF6}%Fx@f&gEB1BUS(9s>YPGE$IB~t_Jm+rLMc`;*h
zx6v@GLMXi=OnC}YF*dGwqQMO=h}F7%M=xi7f@E*<BDfcbD@LQD%&8n+m_Sn(`pXl9
zQ~p!+G5THAZH?9%(EX&A@T{CDkTrH0SU4?o{^Hg33A~tbJ8YB3!Cwh3=s>1^pewvX
z|M_LM+ew3k*GBcUBp2SgsnTI^SWZi(^DS5nkBy0Fr=g@B<xzo0O_0r3)=Yd%^Xd&8
z5T1^D9b-+WNvz)Tc0C;`<Vhg9xP27UYWogo?Ebx=wP&+<$6)1^9bTUHOr!YM^WU9d
z(1$Gp#A{J90*Uqx`@cp+)OofRe104U?^Tm14@yuJLVnyJ5jD-R>jHVYTyw3YneVSw
zzjkNdA!lIEDr8fZzsf<}cPrEnR)NzwH!MGX!w37P@S$wb*zcQR-fC+ys$+h+5rxF|
zD6s`ruFApdmeEYrc;Q1G9oL1fY{jcY6T@fCDmXJ1c(=Fb3r#0VbCbkDc1{x=2sFuG
z5QAW5o*uOdN#6Y-H+r<<;|xokjSLs*ATev|saavj+>Mnsq7W!5z&nQDeM}u)Q|kHF
z?jzJG#}E!oi+xW&hv}rdPa2||dT_GbFJFieZ_pluDv3C7XhIAet%ep4Ql?AwpYU{1
zek4GQ@q+JF8prZBLqL^R^g)O1{49C25&{UdZK@TaA+K)6n9pG9V{kdWeb?g_8R7Am
zhPd`NhMDiZdkT<`1$;oKw}?n&=r;LS60Wo12M>xvQ(J$5&8>uFSYTR}_;jcCd8Oz$
zwezhGEYjwCGlR9R_O$`w=yt$QVuAaN<HARNVhnL}k^l*ozlUDgy6tcXqKyyjxTu}D
z$|*_mf42HF2}{1_B@$T=C}!Bdn$^cVIKt-&30wHxop(yUJBJ92-#cr|kw0schsO@s
zu~h@4#m{!J^ahz^EJ;F4N$W^&Mqp3$UX7EZPK9FHK_Jmf%X&bt=uxUV(@JXbzi$O_
zVXQStozNi#;D?q7iC=|QQ9kZG3{P{ywKJ%TTu`TV3%7d*t6Z#b(7*B#MZ7`3Q|!d*
z1A_>u3PHWy_~29gtvITFNVdM`%R%zV=`k2$@}@PpgopO5ik87jeqmGKJHg6O@Bxi4
z%Sb3G$a+UBYjvw?UIrES<!Qfsmhs972{RZz2S44a;|Ia>1S+MPO1MqMn$uGcy-ufb
z8BdH0pXD7o4mQYz;7NnD7I^)A1gz%%(*m}$%5f=7^#hiV`eMkmql$LR$r{x(6e7-)
zUC6r-9l?|ag$ETckY(!vHr#nLz~|;oyv3czd>v3b?&|v2d<H}y??AZV!Gc*Ch^%5F
z_fodaBUJUlX})Upqn9e!ev~4!YM0!W@T`hj@%cjv5=VOlZ1jaaxe5WbWbxN#PF0!-
zQMl>k<TxRYVv^8_K4c!dDTBZQ8MXKFVeTecF?V$fr*iAoD`^`!$#;sCJDsNoo+KMg
zj-WM}6P_}k9)j{8b}0+$D+<yOr{=VxuKF+kR)B0!lm*j(@m>1|)fJJ#=k^*Ta{AYE
z-#7}jXu{Ku>)pZ-ZwUd0gkb}lepsx=Vgys)#3Bf>^35(u=wSqR(0~-eV!7CpTGib?
zNPKe=tiAGBBUW!xr<?t?=T^H~-FgGJpg9SA^5yzdGXKIFKu4WZ`awOa2vIv`>Txm`
zt^pW|liea}bd^Or))`nPuJ5?fjLI8k%4t16aIjFm&SLC7RwYTpxU`>?DdeX{U86@8
z^+kWbc2PU8GnV&Xb!B!J@nAXyM(uSLd3ZjcsCcBVo__!Cg$w{2<C|{{E?v>0q|$z@
zIR%Qa21zbzC55sS2c!#t8CEEJb>4}*q*mJlfC``DTEEFOU!>U}gw5&IG>xNDD=a<m
z4{v_X&`8}Xm37po@+58RI?oBHX_;q$m~<y#eKo};pcnlHJxCo~QQd7MpXmU8CLf3k
zPIhhahW5weN`%q_6GHhVv+k9{#=}e`jUxvNXps3B9ngrGwJB0As*^iuEmY+wY8^sS
zd!H=<9j;d{T%#@9SY#TtioTM}(bHle<ZEVEW|e8cQ8ZE%my&^mX=L=i)g22i5qOA9
z&2P?GNPh(K$Fzh{CdjhYZ+3=UK?Lw@gkJ`2G{}P@vIHAP(S)jh8t0@`laFE_$Y{tY
z;EGCECyhA*oo?3WAqPeypiY2&d`OT7!E>G>8MAONi2s~dKJqG~`@!}zMXD{Wogdq;
zp!@h}%jNJp2wHt1sYBR@E}{X+>ux3=Q3%%E;jB~KyZYcE78(jg%WFMD!@)0aE2l`f
zI}P!+8^6Ri<|)a!V;t&@yR*KE^tiut@sQv*`{<i;$KfncwqdNUds8ek15Wuw^<W#s
zuQ!u?=!|{(a>rC$JKC1svOqjY;xmOx$<)mozLr-^h$yRhKC+qS9L~*>0W?1!o+C1D
z;c~#)e?8;z&u|hCjkF~5FQp$2=J^Ie>ELtHeKW$ZhjZ@RZoFTChj?6+kYXhdQx1qX
zB6vaZInrl(fjkeN*y-*=OQ!qgyNdg7<0lm+A=+}(&GHu@J6REYX}^jyFg?zQlNIkh
zLpA(R9LEItY*H`*J6^Q!&P8_mxTU&UBQRQn2;^3P&&T3(ES|_wb1M91a&+?baws@(
zk4GmFvLbrfFWB!sG&s&<?`5HgvA@;3hv2am=1wLgY>e?_pRL>Da)ED&7_j%yih6I^
z+Y-iZG6fr0f?sxMr9&&n){Ie%3~@(8wJg1vCY~#$y_{?|nhfB+*a_YxeQ(r?@qL5i
z*`{Bz$~iPt_ihOS3>L7I802ZVt5`UQ`tqPl5>(Q=pHf`0(Y>NRYrzdQPSwoCSeZU0
z;DLEk^vLzm)SwrfU4y43xn&-2^9%6RCjVRBI*GS3<IqBoaK&*i-I6ReFC5RQ7Ffu?
zX`~C`-tpH|Bl6MPz$5MDic3kegi&NqR(}X!fr2WZz$qZ#K9(*eU?=$EGi}mUhTJ}~
zja!mB>_UCc4TVA1+M4lq3>i_CpmJ`K#&n~l7Midn2StB)f+)x9V(sQ9WVjdDtUBr~
zkE4q2gu2!{ykKOi@)Y%WXqP!*Fwwrz(_@oESnwzZa~8EVjGG!nbozdt@I)Oi-lU)s
zaWq4n27V=<gZ<<1d4?%n>pU5e4lr~pw@ZBtThk;v&`<@%5peRsO-T8PSenx6<xN1k
zsM0S+TIHJ&pv+GpK9@eiXbs>{m)gWTQL<t51EKea&b6ZT1?zlb3$Te*p32k5YQCFb
z|4tG?grJ&i$03(|@8&TH^ymEK1U}1^)%P!TJw&1oed@uDQB&-@*`5D08zHQ{m52|1
zV1X#)uqhYuUsLd61yw6T$iQ{jwx533?36DjK=Ph|*g^!5$l)iTZ9@l~2twAzj`B-4
zk7wvtyfTJ1V1-T-frL*Azx(%2`4pQ<%-Zt7a5CkjNJ1UNP_f<-_%Uh-{B%M{{sBxw
z9?R+qk7$F<^y7Jd@&oR-@<WwCeYa;M^?evCre6H{@wca;_waKR49NC&3_{dFWrPIa
zs@U1ciHC?bU)k1YuP!?rrke^Xr&(hWll*fRUb~q2JW_-d^c%*zR?<Ob`MG>6>7~2V
z#>g7kX)HZ=-n=y4M=jny4wX{YZ!u2!5_CJk4~cX#z;keCWKd_%j7v%!>9vtN7U-hm
zI?XEyyr2Egx8_z?4pfJb3=$|_$|@u-R!JhYV6<UqyRV^%htsRrLs3~S`RA%vs(;#|
zipQPbqP{zy*z#<rmAG?^W}lHsMgAclZGKU|(8qjW2F5hDxy0Ddny+}P0VJO-SC>OL
z()&Q~I;S|tzmA1@ost$d`L0)Lf_#8Vo500TxA&sP8@*EVHToY<S)bbnNajlk0Yc`{
zYY-2CYHdm=nvJ_BT0QBE2ch6|2-GqH=n)e~thPR0wAFHIZ6BjVW$7--p~nFBuCjQl
zJHU7I53!P9h4^?cC0N(y%;qy$m8BBAK25&FM@;A~Qq9QcsVI!>(ICzWDVdAw*UFtX
zrFZpk0H0*g>e-nB1PxB$3TE^teva@Cnk&!_psj@GOzEW3;A4rr?US72Ws(#26N#R9
z?R$yEhl^DugDe$Y<`)0j9Tq>D9^^AzWzL?>ernlFaxFqPC^7OU_|<l~HTB4(l^b0h
zKsibo2}_2eAZZUlIJbM7Fe2F1$J)KMcYI$$qGH@-Iy(?_&G7&gaXfhSsH6a!j$<iz
zH+PLIaNrvxle|X-Cxq(wS;A-=)`W)kSt|g8w<4li)*Vs&K|f@b@};^2GTccqfWJv#
z<MO8dvft(blP7YOI^!BJRSy?M&1k7ZDu&-<y^r8A=Wd>g!@C&o5fyx>N~&CPbJUBQ
zz-rtVl05t`XP3JHen833<B8snB<p!0cH>WNO(73Ev0NmRvnYkv0I!*sF2OP11{0Y5
zR%_#8nvA0_btbWwo({$>hZqSgSczNaOSzOUcAzEPg@!;DJ1u?1c4jkmgQWL=SO)ca
z$@Yrc16G&M!m*m%C9OC}ow#=z&`&BUH41Tk;y)DX+n@8{t-Zp`xqKHO(@qo$j>8_g
zzap7Sk{43{ZX(UC5AFQXyJmJTnGr2isuDZ%><eXEapS-?^fID0SMe$*5=VkZS>;%h
z0wJ9_e5|xm2C3a)@PS6efIwwjpE$XlDU7JC-u~u2)%x14_3uz-ToK-Qs<pq;BOb5h
z=K(6so($=~A_ZVO{h7r;nyc{SI9!aDdc31ru`tfm?iI#OL5$zi`%i@L9uuSwyX}<k
zV6nNpg-^8?yEr5bK8-=FjA>U4l#I%=m~l+uIM|pBqy@A^^F0KwJ%n%lN_wkYU8n}S
zp?+f)mV21ylnlIqw}v$ho)I8-W^29bISaULW!}9YlZ;u}j8V@0k9A*#I)~*e)|0c>
zjq|>lcYbf!b1cI1u^4{OouipgP`YmzSWnNirMH4sSjPU6*^E=I*VE%FtppL}v#m3Y
zpcHg0w;#O)ajm6PQ7{BE;{;haRmI9Aw0Q{pAYeU<?BzV$ab!drw4)8*snD&%e+gw)
zd(nF8QBEzrv{Ga0h$8Sh^)%G`dutZmNY%-XOmZBDRklco4uy`Lz7L_~Gl`@=j8*0K
zlu#bRQ9TwhrTWQfZ)Dgq`uZmO3%-l=E;+S?dzO9pc43{hhER(4-K8DS9U3LWuEa;c
zDJKT_B}t|eeN+>Fg^BNlS&anC3@|0AMPa4Gqg3}*C{@<uHKsBhrXtJf$38g@T2Xv>
zAeCdCY_gfH3k>p7PsYy;+C}I?;J@vQI!R#tJ_;?fOc1;BM`9<bDG0u}k32IqcURk3
zmVsmC0l_vi2H#05%MYItN&t=&K0nxpGC1TnDyT-SjOWo`-$N%<w4Tm#oh1pC(2s;`
z_}Wxz=U1+#M$}Dv)&1c=rKsW-oK>Cf1gxPs)?4ll(`J$2CRyu|YT4$V_*SbsqwS9<
zhL%upz2mUbDgUU25qxZwJ9#h++p;s4uf1fdbed_0AQknbEpw`E7{;c?(JO>_Eif%d
z+4Iv0uqR*_;?me3zIhI&&H)udFD4UtZ4mbnkJASYnQQ2=f=kLM<ehS^9@lBy;^K*Z
z>qKt%j`~)8={WLv&0cl^ILK<Ce}T!~oL*NjLuchcklBmB^TD^JlB}tg1BPpVzO$ot
zuui7#AQv|{33=&d0sVDGkGE<^QpKFwn*~XpF4u-RBmVGobOb5(((IoATSirzgXbF-
za4uinln@bpo{!!q3l6_d4fEsM=epa<GNzirDbV725c@uUzePn3K81j$!Ka+haSY!a
z2CqRz{Jq-D4~|!Exxskmzl$QOcnF#eefP)UWhJv7FWra{L4i3?r;v%+SG*%&oTgJi
zxlGX4GaLYhP!BTrnLsw4+uCpFhqI=#K6GDK``rz&`FaI9Vr!UR|M+Nj!&$rWYcZF%
zy@c6>wPnA8P+j?S2DR48h0<vd580;?v_#kPqF*m2PJP)HZaFSS;;#58YEd}47oj&l
z;$%{Duf2&Ouy>=gGWu=A)9XPPu_L^?z4q-VS*#(b8E%an?pAeGjjN%H1`g3#O>Y&&
z%^4-ekVDz6@9f^30Y?;hEzOhTmg))fjNEP0mo@p9jNHJUU^WX?Q2=vucei*I6#u@T
zf%nA8jfJ32jD%g~E2;YWz1h;LQ!hk1njn(^<dSp~VxFC4rHAzY<HDt{^b)3VbMI!H
z7l}xbee?AXwpmC&h<vd-TD|Gb2ZYFF47T;uKdODtDT2DdxZ4iF#`ld}OL15wv>nlg
z0aGWCz<Ned3z}=FAPg&Z3rjYR`q@y77bW8R<`+xqrQ)H1Z5-n=h01_I2Mp3?)#T-%
z3Wr~}U&C|M`B<w06Se8H2kNFhB|pbvMvI$34g%iH>*Wa)j(FOo3~%TJxHqO--uj|M
zSR6!$O`1jMJ`6Yp2SYFD@(Yi&1!iUGEaMuXQNxU<?`sD-@1=Iec$czc;3oR`QT?2|
z78NxivKmy2<0Vww?<UJEbWZCJb^e*M8u%c~o}6{sO_!UuM3YYzr|x_%5RmEJcct3y
zozR4+!Zw^^r4nY*oT;RBZe5SRLX|uANEx8AVE7uC>;p(T05|?WEr7A#zp--KA`hEs
z{527^Wn$-(x=t~Q4eTeo3ZRS0MhLo|jyvNZs?s7MF@cK)8&9UQwx#SM8^5@B$7hb?
zY`pFgV~)8HJr`|e8n1m$c7lz6AiGX`!s*Ht_hPbc3C~}iJu+sRACTO>GwTY{nZFR6
zGKy&aG=sa`XelxC+D|9$<v04w;vsGUrYc4`#4kn!5&uP8d8Y;5qi`_JhQI-(eD>Fw
zoFLG{T&{%q4pwj8+0JH)bP=#Z#NQg`D@yt1Nv$2VDk}rQ8GL9Jo01zUzcz34=1%7^
z7?(*6pZig{Ol^GOm{7{V4z~8(;Grf2DYN*f$VIZ)%CyzuXQ$&62Qc+qapY_$xLjS&
z)fi#L(Q_iQ!!^`L3VHn7lYEe953BQLMws_!vwi4TsMnlnGUz6ECM&pP0$p;RU-BSX
z)8!e&ZLW;SWXq=oCwUe5bvs!C?t5I@QjfD@*x_Rlv|y01jss+T1hQuJ5>wE@lxZtw
z4kEN<6{K{H1@KO$!P=yf8k<@Cn;WZH)`na-&k{~}bT{veL=DyDDK7CeNshPel{y-W
zXQodrBg}M_<F|fVS8j6Xs)sd0MC7G6KMSvxHI)-p$mD40i478Os6sUUT2PAY*E@j1
zJM8ZAr>fNV%YIf|;x7sm9y>S8yKSpR1kVVm;N@>&rk!G~_EqzGYCbLxgiPUT>mP?<
zXRm|M4Q0vFUi%rIAYlCmS7ZC}U}3R~kA&A=c0SbwdP0v^bvob4AYyc#Skx~ZsjY^J
zec>$B+-OY;54cJXf*j@W{Z+G(O;vHrXzJ3P5q>N*rH4kT1G%yKVt}ALg7!M{%0O_e
z>}%V}^p`>#?cy<(tmkAO^VE(Fe%3QHNl%AwHJGfA_9w58swfe_efx)3s@Z+K-XQ?H
zYA~(yEDvU4gyQ4bZjO#8;Zp#cnVY7R=}zK$b9dfE5AO^a!`ZD2Adom~f$b-|-mBZ4
z`}LDDFWBjvgDzIR_+jRl3={e8QSf>Lfag=0t|<)v4sy(I39Zc=!O=FLCdJ+|VtRn{
zC}moJBK-)TJ$C-n%ec@<EUdhw-w~TNQiqz^HttiRkVQx>lge2YJcUsO8f=*+U!77$
z>7O#%;XY<b_0Sx&`OAfdMlc@2^Y15d)VO;(Do9e~IL}z92<iJw7odzgGB!&&17x&V
zE+H~f4Wp$Y7n{b<1mtASV&e!EYN9Sq@{wu6e=BPb_kN3APYwE?34Cm5&S+nwvdn+z
zOYmv>bLt}YulU%GVG;e1?G>6-6Tbe+D$T}#Z@p;eC+W%CG;T0uOV=rpq<6c)n5qg$
z%EWo%hlf*r=)+SVTh?*$zA5uJAm`8D?m35DrO5}LUAsU>60GS>01+2o%$)-fn}zU;
z6+Wm3eRmT_8=AoCg+Li(4#=_fx#sC<A}GGg#EuKDwfP&g#cEz}rZ9?X_a10RgJYr4
z^(=U-+9R2f`yR}Nus9|uy1y|d#hFQJ$He>^6^!NUc@(2i$IHPvQV&!a)g`_JCT9_#
ze6mbrhE4sxr<F%m`m0gUS$R}p9Za6HD?g#$uPXw)&yXJ9n@CEGn6_PuGj%#;$9cG=
zwT9n+AF=;g28XoTj`u=9PLS13BB*ly(};q>cZYfHuA1w|U^J=5P6m4fOKKi|aQ@tu
z$BFQf!~Ks~nSIRM@=Ol5R3tOG`q~HJP70)ak?z5ynNz36tocYLHp%1t?jXIBU&CR!
zSG%^j_Y<?wuS%D7W<KcDrJcv$uhNb8;F3#CAx4<?*7v%n6V6P^P<MTLt>3g$+Ux5s
zP&noivv{B2+U>BNJZuWT5ZAS(<=qTQ(8NC;hDOk_RCDIX8E-@Y=js#j_tuMVWtutF
zb|}`T=gNK9sPazLNJ@MjsC1mPSR}jk=GG?EG6@f|WF->E-fz_9@gbQ@&e0PugPeV-
z54})u3&$0F!}75g{JBJspK4Z6s0!S%gzJD8Yv`TlnwYTDKt4<=`S9o)d2u5MT-oD@
z1eM1L@^@U%<~Zl@G#*Y%$y!;dNg<~_k{E}SU>cyK2QA|8x<z1gkR2^65hE2I#077?
zS<#Ykvk7N1rq;UoiT$u%MO4{kACp=`mLn22?myr_U=vyhwn-aV{_EK`TgvXU$5;%I
z65m$AzoUp1e!tEmi*4r7mhcNmmc6fHLezRw*&~QLq<Bf4*kw664SzI)95xcPUIv1H
zY#w&d(W<Z`+|k1(##>FIiIe$|jd+isCA;fc3%C6*<sdG^O!t$p4kLCV<$^r7f#BcL
z>?@tm%iQyU@oP<p-wzOX-XPM(DsZ_5XHwzxPawj3L=-VFq<=aRnK>0+<Kr>!cy2D;
z_jtfTLm8qA*2ALLx5O{v5y2x%K$b$8zCz`@KIZD*9mR-vF+}9uIP#T7@!JA~-yO;v
z_mU=oBPBCpdMIMsoI7R6f2BtbR_u)p&w1bbjqVPie_MH#ks21NN>c_!ME6u`x|uwn
zU|$6d(fmtL(FuEm-o4&$^3FHHn_ZW+0Qj103qY3&EhNP8om<)n_K5|&Kl@Oc=Fe#B
zAkeRU2)7+$nf?{p5!Ovqmg3|ZOKK3JLKUQ7BDpC{zaAr@j-DX=+slZ`$44EL#}xs$
z9tOoXWZEzxIoD7!|1HQ65><F8Rwv2k8NnO#p+No#)v>~;fRk?`Q|_J4K7e#O03{uF
zIysN+?)RWTGoL+W1-5%BkW7RF3Ol|EN$~nVsPyuJP<ZjCO~GDOpy}%tQ5LHgyk8CC
zD>8rtDDhlkiUp?;<qM53MfsbZaNT5pzJE;BQvNNZpizXYv_0UwzYg5?gxE#dEWA9p
z<KSxXy(`Z-q1EH2maP>6L+g)s`r*JIq3%`pr)G81zL!IH?K>kk3!^fr<U!qr%8!ro
zj`YJu_jitll?9cM!qo2Bm6J;FdFo6{dH(NW@>cOZRy?rMqTLw$K*LvMpKFb=;ypea
zs#sZ<y^kp1Y8snlLq%SbIqwiP2=4Y^c7<i2p%bD=<^w_#-n*butw5pcsVl3sq{LFD
zi4nC(l5|fx{(CwhJj{kTpGi+#_4Hq!JWdl1Vxwm+ec!(x;Mr!tZX<Z+^Kl(l!WDqN
z;AhI$3kLgc<`6nh{^Oy0nPUmmcp<%xMlk%>kfdmtpu-#`PgWDaLIkH9?G96bd@s1$
zPPd7Y@-haRBlw50s8nZ)Y2L9J^kWEv=c?H+;}#lUD?!^p2G@Q|J(5_{%HV0BiqNvM
zcGxuwUk9dK&!#Qk(BZYH0kB*&=K;f@EL#EpKA8#S#u}%Eo{?BL@rE+w8_``hFla*P
zf0tNFUDp2yW!r$;)lza*S<fHPM+`DvEfFMNVCBYzWapi`8fyY}HRSo6b6A+?4suNU
zjjMI?O0+FIypBEu$UC6_&}S^~218_`M7jT#>K7H}CcG4-)^W{coio|&2;?g%!=_`K
zdpqB`XR-da^6|uNHI%dI<|sQ&*i-a$(mUvvh!eR=R5K?-kR$w1aD3yXK_^?|1FVi1
z0R9*b5>Lsj=RshQ1C{nauaeK}r5_zb{{0#qA}c$7lC>t|wZ-`i@v!q>S!0Jzi-tZ&
zhqON$k?gf&m7TX)Mo}(k0T9E&Xq_e>d)x*`r)xQ#CRVmyXotwHpM^aSGhu8eShfSs
zs^Ar76~^WE)af|ze(JM?-lR{&i`wS^vI<Xs`tb5?-$Qu8l%M_jYh%mTHcm~}i3D#%
z;Tm8(n*E7>5xq^oZcqr~@5pP^QL=;;`xWfnStpgw)8bL$%QuXMWewv*@QZw+o<oBX
zF}IvV!4KU<jiI}siej&j0t;M;I5Jwt(f2+t<u3E2@mif5kCS{@mi~TLSbc>{OS(gq
zx0#3qlc%|ma!h&?EkO(8_AyA?e#0#G#7Du{M1}O23qOvOJ1$4X1W9!qY!5bZxJU8@
zb6l10(3|L}J~G^+Pl%r>X`a;IpO{U5bG;z-F-4?t(HGB`x}9&}MOu-Sz}o-3p@qU&
z^NoQ{#AMO*=3v-ClnXFbgd@E`<B!#{<Cq8IsZ+}>U|P4Bc3Pk0+Cq?&J1{-i9ad_4
z32;i&0<uLWgqonBcb;z-T1(>@)|LKDMKww%{Hzxi@&PZxedHsmc%e)LqqSr{zDF(+
z;Oy0KDYrwGNp3fwl88i+KjK(ppR*LblBHglpgD8cAhZ?Cl$ls5J?df0>ct@0R3KL@
zL_NVRA}tFpx`TK~viWCV_u1X51+fR>HwVSw5KU<RXGt?zMZXeY{b%)Jhvwy%$_^Q^
z+akN3^wF1dd%((^_tcMFyoG>)nbwKjU;&l;2OnOY$bGL#WC!ns<X0{LcK)wE*|mR}
zb|d${x>1^C9vLi1ZjH8vwi2VGyh;OGk95)|A9$uc4;&t!ZM%13sO0ks{-xj7y&zeY
zQbQ|Y0M%9lq(HohWBSn{T26b#I@8+WzDb2RHLhUYhHiW?ReL2+faAzH<La2?G;MBB
zrp=l)6&}=gI<8$bRdBh)?J(L<kKYeO(nu=uIx-^o;<-|JNEX!wtHt$(i@&KfeW7x=
z?+_yNb@NRf9MmfRrCQQ5#+qX9(j_>=n=J3vEUe!f_?)6p^@kmHH;0|L2ja${qJTwU
zg7tx)srcu(-Y(*I#0Rf0p-)M0^HfL#iOiH`&95BWer&d?R@gT6>{Zg#ZG(@jkJmkJ
zBhZbe;a}#`AKCK10^FP_{g8eit}rkVgV-bAF7*~3=rL*WlP5B8EIsI_vEdut=Ljbs
zUHT8<mAW7@fIr8Im?l~rc`s&FVyS(-yJ*tG9X$bK5<op_pzkpwFJ44@)bU^HMN6bX
zWBXjHCRZQ{<**QQ9M=$R<6l5u-g&{Z)xH1DF<&@NjRDaiD~Nv{B1l$SUv)A}XV2?J
zIpcK{k@7k1C=-A2w3#{4_H|9`gdZW(%7?66=p>7lq@K&)FLpo*O7v}CPdtY~lQBdG
z9<O{-7h1b&FqZwZ_><%D$|pY{B_7MHU|b@qQ|?vXBAzP>r{={kNl@tOI$@;i+xMia
zEB8Md#?0bM>29C*5oPO-JzdcF`TUN+iF!l~fVsai76s6ZsjtlI7q)7j2XdDnQ?)Z>
z4x8)O<tHv<8M&jOL=<FhSGDcL#oHeF9)8tL6MF90_Fo#@l8($(cCd3IoPLc^d^J;;
znL3&<Ul!iZCz*X%YFBB;y&A`hp1|5p4;A{~X97Nl0?L4v^T$L62pZ_3@kG~<H__mb
zd7K8yVoULO^~5i{8L0W+b5=GUMHPMe=+h|MA0{*AtZ?uSVjTrtgZ8P#3fgkuoJ_~&
zcq5b3byI(nJ!D!mxh0qDqf5Sg9h7gC2DWCRwj$|oFgLwE*&JC<Uj3&DIeoV1j-_t3
z)BT?op!4N1_0}o{ign*|jtZ5E+?Eqj5gdG*$p`1Qx;V)apL67kO-KaT3N7gdz|2jo
z`amS4{y14U1^6@GL1NR&g@M3L$l13fHD{nli!)XVOAL(BnsR0B-J1b)vA1p(DC!qD
z@0~cyL|_Nx{fdw3{^-KqyUm#y6|-;Tu5S9tKWBH#JwzrUL-LG|H*Al(nPU<xcQW^k
zc#Fo3t3=hZs3u$<d{n`n;At@HODM`phQ{)6>o2mjOo{~(r(O=-VG7ns$c%^J&S1;g
z<m}YGlj5_*-Se`QBcL+UfqZNjZS3v<h*XJ=!`z6Nt6+tvs-)Laibp&aJI;03(4_L8
zidqRtlQNWvTj_)5fDl6=zgL5!o7ULv6dflqR|~?;#2dz{!=<s6KtzjQb}LCex>vU#
zgGj)OWGho`q_(Lq`NTH4<(1^3Co{=0A(Jo?oD8jQM80`IQ#w&moVH5Qz<lW(6h~v%
zYy5`A=H9K-?dg7ehgjJ+3bwIeO1|G;4PzBTqADYRu7lH)f<(Ansz2Z&BN3#2C*52j
zRmmIBFM)rS^Swm*V|$Nn1QlhPg>>C^zyl!r%(QhaAi%nFCA+Cf=@5f+We;{S+py_A
zj>)v)b+AqMX`UZQF>GNAf_qNU?i7pO+U~EUaZ3~_*!5VGq3Vx+qD{`X+Q1`?dhI*E
z79#ADt{md;WF_>|AEiq2MQheSrDX4^PBBsnq};VBAW^3(dLY(i=(7b3i!gRPr5|0i
zD9{r0&3bsRtbrqN{OoS*#&M8uv4AZnky9=;6Utq?)2^_^B)OMpVM37bXIf#B!U*)!
z+SN}M<CVvDUtI+Pe3eyK?A;?lVc5>IcG6)PqrJ&H)!=VVLd7j)sGZLlW#JFDKYQBG
zSsf@I{PqjCRK+PG9xi!^ipta!&AM1m@%D1<t*beocaO2Y7xb$s!cOzm9iKJvJ30xJ
ziTHY=!*3~OrxcwTuz$J5@_4LW{=K**KQ;+2dt;hBPF=iVvBypx^-sqLJdR`JM6@~x
zHk5Gcv4~NePFu1dHcNX(Ftr<M*e=<Z;MHdRp;^X^H4<8^OiCj1r<A#IGc&<=p{?U=
zefw`Xnk!`Ut47qJ*`u){SY#ZYO0tQgp&k3ZymM5p0i8<7_Q|aO6YBZtRV0ZGpIjY(
z$T_=4L)ewOn+?Y^&;q7Y%KwZTL!UbtdgFJAcZ?0Ls{>k0((mPWCWZBg`K7G@88Sm*
z-(@Ur%Rp%di=V7cg6jwvuuK@ETJMc4qVEK<eIB>#NJUFXLYUOJik|!BcBi=dS+eS+
zXkfp7aUd9A*q%KKH7Ae)e1q@;nPoG?cXG=y_TAK_i%&ak@<`Bbm*jXPh`tgN3eZ3L
z@G8g43>hSo<J3_D1MA)Dd6x_AVDN6YqkFb^LczqK?qpl*BiDa5PfB04*YR+b`jL<@
zMFf&JU9?*{010X1RwM$m?14|t7QFvqVlw2=qqZXYq2Hn0rznS-`ZBZ4w%xgVFHLqc
zAs6$5!i6^$<XU`>-95FG*SvLHuZZLOD^bpu!iAdho!x*1NyA78D3yR-y+pPp;OKv3
z+w~C)ss=DXt%zQ4774KEkv&5gxVepBD6>99`pg)_V=KY2k{#Uf>9%%FPQzW4{94k>
zxx|Iyhu2tmFJ&ThXQ;!%eoZfn%=5mxxt~!5;Y2qZ!C5rY<E%9lWny(y+J*Jml{37M
z2jN;LU<n!qWO8G*q9!1o07~+-GH&dmc71-L*4&}?Zv;qf!UTa_1p?4?y&Nqsw5F_r
zY6q);ItQ1J!KtDvW>0QQbRCn;6{BM>W4_j$hkxYH65v{LJiN6E_)wD*?Q_|Ew1^RD
zT}tKxJW{>s!R>}ii<lT;$Wv^M;$8s*xpf*5CWSl(!aC_biUWLQtl@%TXOgg&YoTAQ
z9{C6L*Z@-u_XZK?rTwqwA`^~-o1pCJ>>swq<=G70s|tF`o&y=HP$vz2uhTqzT}7j-
z=SmL%<@QB}mFQM0nR>{fW1+gXRYfyhmE1PoHye*->KVrFbEXpL3D+`jrWdieNoQC`
z^hC^Sj==L7o2Jm?^QTzN{h{$r+4QRwY)`S~orb&5OQFJ%py-~(_x=8-yqkPoxJ<d{
z#b#p)`~$A0&F{e7W92|T<hLm)NE!yMY?}4*(F@h;er!yjPA`|<)S^KtX71VDo_0(|
z+kX1)okUY}<v2@7_pA4xtUKRfp}SWbVT)GzcpGX?NRQe~wOzF+^PgQc^#sy6^&L+o
z`V!s(nV88`#2^=QTAHj5k_mTNs&)dwS#Glj+o2CnW%t;l8d#E6H#i+}>gT#S)_aJ}
zSbfYL;<UGBwiMvOJ8m_kc^y^4=YQ`v`#9q!xMu%Fuc~eOz#Ks|uk$|bF2%7apJLbz
zU{S0+bA}Z<oV=YWd8*x>?sI=7h&<_5E*p^ESKKQW!}7LHcUK-#o;KFWeZm&hWSx<9
zXDWU@rBHUw`!irpWQ_k+XyOTREMP!D0TY?Yd|#P}QyG8S%>p2UWxzvd9YGrLloe~f
z`%q*pi-H(dJhJ*$T;OXwdELskVp8=1?<?e&DH>M7joWS|FX9~rm8nfL^2=U8xJVV-
zd+V5V#O4eff5LAR8}~i;d)cjt2cEqcrqCD~b&Yf~!R<f7iWmEx`cI%vKcscB)VQca
z=sZUsug-BocfwfR2ZqC!XcEV<G_HXRF{!ejCH;<Wr*oi;N3$GM>xw`5R}XhQa(RtR
zV<>e<WPc3Y<dNLk`bHSkjlDfR)JiqDUk_!;Q!MedS`mvo=+ck`7R)VV*0BT`g*SnF
z9Jf=Y#BNVUmVX6t23i)@Fl8#G=m}aX3ce;DIzPelG|e|r;ehjHlnj;Tq{q`cSQxh9
z8`$QZ$0s4}8c6mIKNx1gC*J8~0a~z~57?<Fp%|bld|k(~R=ER?M?$en#R2D!LrGJ@
zROBFiUBOmjk$e@&^~YK5Cx)%Sk96AWRRaue5iX-|4gln&O<d7>dP4>+^qN-}#LJDh
z<mO3iZ189Pz+Vu$*qfn=j6(^`S+;*t9pTdky@>2pRXWuZOYtC1-CO4|$Y(~H;+;U!
zSvbB2wzm&_a6T%t>=ZeM_OVi*Mpll!r^KZ4JWp{Q+^JzT391g_YJBlP^q@IgMJlgU
z1t{d{^=n_v05IL(CUW^DgodC7)UrygM?RNN_YY#qRPh4~KFwrv<v|0*=Cfqr*v2z8
zpMdXzJ7#HLqoN35atO9|bO>(2BHE4Nj>OJqvLPI^pSnCswguFQk7)_X$eH5bu_c)>
z`<3(`pfU<j#lV|CA2hNJ95YOR__dsVVVb_b_E6pwJt{1c=cBvBrmfG;6Y{&8IfVw;
z22`J`)85_#(z_L+;W|epJ$3hRC|f5me6TbY@a-hiBF1DjCUwlxQ8i|nUm`Vx|7Skf
zrr)oC1K?xzIRA)ArY~ak0dQMYx~gOO-Hj<Eg&`>Tchzmj2Rrv~3L$0ak_$EP2r#sN
ztd-Gy7$FUT)0I{g9KR*|c=bi>w+Bx1SkVf$%hazj^7S>DSq;Er9^Z;vbi?#Me_P|S
zwqbBDi79>NMrdK>2dMuu=%TQCDG-SM!nxol%l-|@qd5P?w@B+8zJ8xM51Q?xuoF9S
z65MU9QM<Q#4~>||e?0)!Nw{C!vqO5hW~>rmu4wY8U<)fA%zyyA*EHg;&p_#0)ZLBs
za}j@tHL^?ojK!dmQ88Zm?pMFCDOA1zfBZyL^(!j2g|4|l0y<gPko5trwNHvC&&0og
zK8~sMpN;kQJ?uU#j6S_wP4zdiZ{5t!LglHdk7ex|Xb5I;tmMBC>VRr?9{a#519#lO
z2J%$VRl2%p&Y30F7dA0s3)EIH4VQw_9@f8n$;g*7KvG2GI3!TZA^!w9S5@uyCrIz(
zbn<m^pxDet9*|ajbj$9e_YAZ#jrBK3uOX5z>S*}Kq_S{avJhYW^10<&JW~xcmbw^#
zPNJD{$ja7g^}z^4Q?Fv|f=Z*L(ABz~PcFr~oMjzamDwWrs=d@3h}det>h1JIBN;r&
z&T(SWK7o#US-7F&f#BND%VMHqy-A4}-M0d=&-DqlAUpkW8~C-!-5(mUd5KL+MZ?y+
z&@rU;UBnyjAsXr^&I9w`RYImf$mD*>Xh|7$b4df5tHWuBCM@d(29)F6OW)MvofQZb
zyE_bvVJ{*;H5Vjp!-cf+4?E=_h;qGfA~}(!9zFTjantv-S_r^hH9YxsXx%tKOpy=u
zaCzM{Dvhf>vhti(vy~=*Wq8Hq*SG)Y>qEX~Y-S{`pd9LjS3VE)slpvHHXX|eSvAi}
zQmajv0z7ZH^MJf`AhU?c9XR-bJ}mwDLzl~47jz*|<f;(6Qfn?i?Uc#OBx{{YHJ7>z
z_)lM9{W166&EybLik9Gm)gLGA<EJRvIB|9MbAhd)Aq4V2)|&Wg)!*Q`NUNvUtg5_+
zG%qU%&XH=cC-ev#XxD|us8%I)g5EM;Vkl?ODBc)_q?KNC<``(@q+!sD{rY3yb8OFV
z{hZXD*2zDl{9axz1#!{!k)h4@I!*>ZCKn0v<V>0*Sbg{ifY^iUpk{OIZ6{N9MILRe
z={bjDW&h|)GOJM5IQ1No5jIA!(HJyWREZpW;I9*oK-Yqly0S<dlzywBRLhr9jhd<L
zD@at4=H*r7;JvUY<^_6I*hvEq2DMeZx+~pMP6aCLj|daHGMn7^H8}My=LQp>fzr|j
z42l1fYkv|KGmI!Pmp^=}T%#~__9a+C#Zr(5YkvAy53CHTC5IXQB1}O-U*|XoZQ3N&
zR*CEkUGTN{l+=}jb7+x1o^?R=?|Xa-gss+9^*HRwJO<N;6mK2^2GQ-_<H>ih6JE<j
zT=j*I#YJ}ktp~LOk1>7XMU`FD1amEItB&|_CjIS(bjcqnY61hkI-3u`SG|{Wy^lDS
z8C)53^S3mw;;H9+h*(N-4lf1xkxm!~AW%LIy@DNB<v$?8e1%%~Tq>jLc1q=tKRjMa
zGB)S00y6RL%*b|x*t>9e!=^jNPj%okT_tP(N)z%@7BQkA7y=Nb@;W~V_YTy5O%hGD
zO5R{UzsNfKOL>fUTz^>PX)6Hq`(I40{mA+bl|O6d^pEL5DTh6%R%=?xq;pb3`wun%
zcH*R8YhN(bB77~HTY9^;hsR6I$1+}(Zp7R_cL6r49gtu$-mCmn)jq)VumTupXvd%k
z<vlHo`ejO?9g+~#xD~g_nn3pbeyj;yXI+n#r}QwV?YjL&cN(Wj1B2EBFfI)dT*w<J
z3LZ=guZjCvNLQ`$dX{O1FlEp1`t#`H)VE&bt-wPPp_A@PLG}M>0nZ`zOwRg0s7A4h
z39Kt0KX3uNdG4JiEZmrAzElHWi&#yUQ><j^^!6O3ghzs$otS35&NQu4s>SOt7)F90
zPg!DTH)J@#Yl85*v*pJ=GeB~|@#^nCVgbOoG%s*#UlFpEfHW3k4JraQZ47D~382pG
zfSf;U5{BtVRNuqAPSRE{P^f)rcdDL^iy!}7=(DE)%BIMG$POhi#d@ayyvpX;GXx1B
z<z&=xB~yX=U-5h7zxt!-n(zg`k^-9WAXIoO`xQT9j1cTuvt(T726==7AV{_Wqea?o
zXk}}l2ipo5hS=SAk1?4`L-F7$erkRyw!&(|`eoYvdkL{TwQL3DANa51SAlnpOq$;F
z)8><1B>lAp12EotS|s==>eJ*>rr<RVtUkr|H*A$pzH;zBi7HNg`gh=n5=Pu?LAgPS
zL@!IWxQb(Sj4$GjR<cbX^hhOZw3B7t)Rl+ZD7wN#cg>Z8r1;`$UmI{fEx?W@l-+Qr
z;IzYtLupWtDB@Rtf;K5b?sY`_L#yYIVJ{7VEi??M(FD=+ipkfMgDz4B-UaoT;`!Lv
zF(jb!uS+8}RxQG!#fnj69jwapvmIE7KbHohl*nK}7Z6_PO2>v=9Ca0M1ztF69SH$G
z^X&07>%KW=vBLlgHY)*ru@pCAmx;RhM<A{!%e*Yp!E+$kIOpWZz+Q0b-@#XLeAFIB
zy~d?;LFjm%jve|CdN9mi&!1PaGIg55@V`JG2(5fi{W4<|p+IJ)6u7t-ehDUGeOU*v
zfaF`Nr>+50JoU%B*y+fum}P*4p&u`t%@@_G1aI0b^4ztQlSo{`bzJHGnuF`U{A!Hn
z&nj^Lf0`r;y;m3!-<QA!03+{t3bs4<J=3{ZtewLE=46d&->GypHI2(wI+Do@rtPyJ
z&8VfLP15h6X3Ns+CGsW>F%D{53k9cY_?!nOb!khjd4kj7oU`#_>3}g)$#YBPQ2*bl
zJ|+=e`p#F2rSZnJi}4_FU6ffX&j0=9Q!><w(Gh}=cl>PE#@l^!vtvy^cn4sMQFYvS
ziRB6*0XgisU{#5?v~~Tz+kL`J62V#9H~iH5*P7xIn0(8#vM!%U<C5QV27+Hqn`c5s
z?UPwpeb&OPvI_bw_6*f?T&-kn=LQkTMA{A-Uu1+&u&&b-BZ!2WUhH;LDTXt(jXL{U
z)0xxqNEXfVzv>LG3#p#a_x6P8aTIem?~r2DD1WgI&O?AbPB5|WzHlu|;2ZKILS6W>
zn<)YM9efkMy^T50>$q)ZfOr1b4=ICUuPy;2AF`LDDj1WRot`3KsaB7nl2z7r{C(Bc
zUf*I<aZBDP|Lw0aUDfCZxpszg!$}F;uH*Nj-`2NG<1jkSPW|zK&*WzLEWV3Kl!jso
zqjEU9B|Omi>SWV6KPoHA&6Ni&9{a_rYOWH>e3L*Giy3q10KN$HiML4am<#d|QS_EW
zc!UPzdbdj7R;7cqBW7~)@O_rzlJr2>co0;IpUeFelXe}u%<y3HWZKW5MOxc*0ZU{&
zz(w@<9zkG;Ef7Xp1-V$ApgNXw@09W)+C2&n5Nx{a_j_KuZ*0$E3SM-6a}n#et@Z<K
zqbsxeNfV;*3}mZj)q<Z%vnMDsU6pMdqg%<|D>wKQYb>6CWZIz0#+C0M&`Wy_@ep<n
z=P>OirVxU0TOq#6IkY^W^=Y2@{Z{<m?yN;#0hvxxoE*q*hfm?Y$fZ{Tytw^*7SI6?
z--^5KUQMaaJnsz-w5+P7{68_QPz5G`bpqd;+_d~!@YR?cV~A^$)4%!<gM|lJK{WCK
zOM1(^g)-ZnkAN6?BIEb}UEG;avt1x_z97}A#mF!@4#BO7T;nzY3y_Ec=VY+_guEDO
zHwwS%r|m$ZP{vC*yk4=Dcd_7UMk143>MMxY{`PUCTI?oS#ZZv`%~G+JqMe^G#{cf~
z^I}WANjRI;zD5(G3Gs}O;CwEZ3e+=y32g4|4NMXP;a){td^5#glsB^yc-@ty+7o}0
z{%*SCo=X6h%7rqJ0G9Yr)MVCuzu{l)%uTWK@dix-aLYrA5cuU}#$9DqgOwgH*Srf_
z_t7*@*!xO9AP)!gt1wrDHh{8&DiMpmIJrviWAtF?rXz(a7Og70^`bvp4Cylc?rA<s
z7d`sm*zQ!z1K3l!p^pU(%AX;=7eh>kziVMI?Ssed2}?M3MkDQw+kmy7`t4y&AG^>0
zU5}%h#jbZq02PYsxAc?7vx*`~zB0J{!B-$WFx4?%%wNH_zVx8D6v+IH;v8~Gey8W3
zYc9R&0l4Z6(q4q|t}O%ZT&Q?=z4?JzTZ)}qG`>s3vm+k4R4mveyNRidKv2x?&#!d3
zQm4B&%;J|an_`_Y;}>Et0jcpy%?Wsth^}Yf6CyB=LkcpRbqMnSR(K43GswCo<HWcU
zz@Fs=^U>R}xBv?1ms_SAl!H}A=K;pzvE*Z7Ju&@J;G}AjVWv7{6MOAtnJF`2v-obw
zAp_;XkJrF6q?JX}OXX%n_77-oJ?1p}pd%>Fl~;6i4~N<M7rsg3LF?`PbAFxmizkYL
ztLviwJ@Yg!@ZNJm;f+*~Q9pI;05D<A@%^!w#$P|~wfpo1#eYIz^OEGcq&GE6WHw?R
ztk?0+tt_u3`&%IAfn?atwzY!sXu%3G`Z6ffI|v*g@LmAu(tH&7UtObb<;7A^%*5QC
z>)f^;xran4fmg5gJTaQ9xECyR&enJ_Vl^eCA1(2}t9c~?9VXS6C{%Vsffb|61(YX#
zx_K_w3N9W8B{)i<*iJO3wpW{3F`2Z~*42MK!j{+^8)>>#*D?IW%RRs{lk(z7GFk#~
zeoCsu9P}{Yim<Yw)*C+Wd!5($ywn3kWvoTdb~e3-5yk@ZK|1#H<HTLgrBKZE1Ik^e
z6PsZvE#`FjO}dX8S-lo-`8MnmXbH28M4#2F>wBKoo0j|}JZ$rK)>~;(<XyatVK@S!
zXGmbhNp6Gg^L$)Ev_&|Pt`7wiQKAQwOOd4LyOESTQnhs!PT<-6-|s1fZpk+L^V7dw
zvd*_lf$jbUMy{z)Zrjm<sLkTan|+IzFpeb8v#A!#Kj%P9lMC?a!HPA-(IEZu>=<x<
zuaihOb`eu(L-hY$O<+~8;wo<e-A68pZf(ulLJ}9PREufgt!rh1Y*Bi7dRF_IzfIz`
zkN<D&v-{*iiI~<NQYXf>J~qLGVJ(i~65aHuH}aNhwE`2w;&h%Tf2x5{>sC5)IyMiM
z2WfJATbIDL+?4xbO=J-5EM~V7#O_nVcmQNgitpf8XrkS@rH(z8LX(acSSHmDJ%Jt^
zx&MCcG37;h*2@B#$QNY)oO?XR)nO~Y|L*|+hfSA<S9AMb>U-e7UORW!`(dUpw>3)u
z|6w}@`@e8^Rwb<n!8B%<ffzwYP`N0t3ur>@&gjj&wAfKN=t%#pG^S>Z->7-!BfAi<
zTxtc>MGjH6&1MP*UGyQ}vuBH$>%NA<FN(ZxExD14Y~fsQQ|@QlTf}fJ^b&Xdzsrmn
zEcSP5_h<ldJpMprhY0?<>1wQqvm#=R{!*F|qqMd3Q~1X?J+kbV`*Oy|Y*e;0|3Qv}
zG1nLnWHZc;LfC!Qh^qkwzV&{@HhC`TK*7jb#hMUVaQl5s<yrz5<i8HS{m{-H%i3uK
z`|tY1>7x#`>snMz-jg01n}|)I-b{D|`0p&GM<}v_Mf%MwsPx+~r<P^$yJd01IOFI5
zBg5D|K@pSY8F^MAplK2Uy_m)Rl%o;L3#tR`QJQ4c#;QG`6BeqPql$RX;t#&fqW}AE
zzmG(_cH;>2nOQUuScw_7k=q1PuPuB3JNNFy6+7_J0HjJJFtVIH@zI3fURDNRbl1~K
zipWIA#E<RS!TlZYcbk_&GXtR@9r$ZhdMtf$ke1VwF_z2jTO6mzQjsHA8-|60FQ2qB
zX#U^w2AIH4HO2tgFCF~Ven}@?#x7e~4Tk9~j2*aqxzWXt>5Jwp9ys@ir#DccpW^<<
zJGfD<s{rP@Zo`x|7(%OJZ|^3slT<*-bU*zmE<J(0p&rPOOu1-dj;^fM2^{lu*(v5~
z4mNi9SXB?Skr@8pmHHk6WX1urN~`Ps7_FMZ#OjH{CQyuNc}cXYONI%p#lCC)UxXm4
zq@C<9UY0iyXh=n0Htwj>TnC)4u}S+6JqteA{{obmC*Zo*IV$<04T+f22w_RCW%d)%
z8w944BRzTvG+=xv>Da6qQ~uv~7}&{!pk_}!+p=SLagxpf>5}!8>omF&_%!$D9nCrn
z5*)9^G@fJ((@wSE(u?lvF*7TGiy&JRAi0<~(aj%!fMSeh8$5us7^l8OF4^6`Y^~}?
zt)QwOxTXv6ES^elpzW<=tzj7j2g+#7N(wH7+V_@0w}1lUGxu+)r#jRQPoi8*%!2n%
zY8e-I%Tp7@<Pfay&~b#Sz1zS>VVmxCI9m?~)ej_m!Ms;?148SOTj_j*qI~&=2^qb1
z|9uBEAu5uPGSk5a^sNY~pa5$R>uVjeH!0`!>jLvz7l2nJR5F_H<P9WE11BnoP@%ZV
z_@g**<U8W=;P<_bA+KM=UUgiiKaZ2}*g?{>iSxEdFOei4eC{y16#oDHpAfP#i-6dz
zd71Gcp^B^FWVqOz1GWf&M+gT<Tw>k<5*Xj&uB4mLeq=a^3m-@c(7Qk_Q!iX}OakvD
z5~v?5lIg2;%`>8W2PNi}ER1^sF#8IyOphE)VDg%<;!aP@r-naWaNY%(b1S;?{f)0H
z)`SJ-Sh8SLro15AgKZ3xH-y<PFEK)0;sh|o(sA;cdefEa!6-M^ukHXsdE3z4ZSL0s
z-VrN8tp9&^{tkW34;=;$TVx`;<ti849pTb+l)(6$qkf7w#z^BJ@nzNU>uU&5I_ng-
zH|#fFFJYj5C=PNjfX{BTUZZF}F=SOa#RRa3s)yJ2OvR4livJYoUIC8L|JE_^k6RS~
zcPx(8RUwG8eBEa%R<<9O1h!d_jK>4$Gazd#<<>pk_sv5`Ru>y-VI5C`*ok*OZHt}*
ziKaAw@mh1!E93dvzZGQCjgSJcx?&`}?l3z-H;d1!>kMEEw?9j``REx9az;wNkHjxJ
z4uMZU2O&6n$bdx-@=fa(A1K9?0+<?*$~4hVO7y&D&?-WBp$FJGLlwtl|I-3uEr?Tv
zgg4V8dOG2Sk<6EX<`pfm@QfP<+^bOpUJpiRNj<|zWwzq}W2<7T^X~fucc0>f`{X8<
zR?t`vz5#vt{Et(jz){8~oK+gLw&hh}9>8i322?ya#vTWJcsw^dY;${_h&x9&Ghjfk
z|Fio7PA%3|U}?LV=k=bQg?Zl~ZMpuxs=hj|itT&*0Eg~Q0qJfj5l{(9LApaqx}+PF
zl#p)43n)r=AG%YeL_iRb?yh%_e!chie*8zrIWv29KI>V}S}VmcvD(M<tOdlqbamiM
z(Lh?Dj}~HJDew{X=Eugsy<C3S9Rl~Gti+na<EYx^EeFQW$Frkc!RqlKyU)8_&ShcM
zIyhgGAM!qB-Otxb-2=wQ72`2)zZZrfEuFO9T(t%6030UpV<es$Lg0K&M7u9O5I>gS
z9|njL;wqMa+1<S>EL_W_WC{oAB6cvYZR-1o8IekQtVVKfu@pe3_8vIZ?m*R4yCK<E
z0q#uT&DFrrvlbG@$Dd`uc?L~{Hw;Ki%Cx*3$bE$XfWHRK^Cz<4v9f)HSgD!>nDs}r
zUF+pCZ>W+0^*B}T+@x8Md9Dm7#oKq3?Kwxun(OE4x2}<kWny<1P#8-f*zngs5m_}g
zaM$*~heIC+RLNt5H#67Hl&I`&r;Zt|*Fx}{kS5?UeOMN$va2QB_{qVl<GNyLtAKwV
znDOm$WG1<Ub#hDNn;>}w=f+0CU>56t(^eT%xgAcqtJ+R?M{0b5xeS<>ognQzDX-rT
z?4|9-9i9;f3t}j_bvHO^s1Ur`$Nik8n??6cE@meC<20HM^Lbw}r|2^H{WJ&8Ddwe%
z5b~xs9|hbB{<fGa_yZegbKzoXPHw$5=H<xE<>NCkGZx%ofA1kV;sQLxHjsuH`?xIB
zY-*MIXz3g^Zy4=FLA%`M9H@#mPYs<R<{;9J-RRwOEz>~3<?+9mtO7142Nk>?e4I=z
zu1s`#T-$0CVD_rM{pNb-=A{aYht>rRgH&TQPlF9q{e5pgwN)aG-u;`$-0h!Gz2-HD
z*!hEDM-}KrY)GJ)%66$(|LP%YFkl2ZjV~9;(WM)D8KU8tMlBxcB9~x!ai|cc=vk%f
zg3U~E^a7$wAjRWb-`D^Vs8Cwui2t_R-ZF1s{k-fdkgELs^ItNmbt2Q;i;3EnJH{ss
zlgW~Tbbh;Srgj6*B&^66nBUblEpwNHYPBgjw;%*33Ne~JY-tbbq|%W`M-t&9MADLt
zOMQoaXL^4hEvEtX!pcsH!96CTDS#xGKtlCMz*O+~#V-QeS%nKwBg~nNfTHWcWX&P~
z)`}fX!0C^+0pv`R<Cbt*pI`sD^P*h_t|^&BK>|##j|;V4j{=HjW1wOD5ijj1n}P^~
z^66j_`j)s?D8Qz=W{p7&jlH+{{_ih^enFWo0<uD|D}ku(6TDrS#!tW<gf_<LRa&VC
z^AGywfLHUXf^DaaK8-y6@!y66A<rYwbk+C;w`vC_zQtPO{nx2*>UqH0G2n?V1QDGY
zfjm1dhhy^SbS(z<<+4!RA>(z@Q;~VJmU4|{lK+mt&{VM8LQ`Ez%&-(;A2-T%3|+b&
zt+tG_@Pz-FiVZ})YtVbop<*}}j6H^m{~P;1Ge9~85w8e7@b;D2I!Kx}_%G!A13hh6
z!LPn4u>OlhDQ;o@OtAu+p9N+Wv=MQ`6W{%XQ-41XNY4wX7P4tt^#h{*TMvK!HUp)q
zs(Jr+Y4<S&UvmBV8Vz}<OS0$1rJntNEkq<GNgE*UGBdxX`|n)-bN-k<Q2<R>IC5JF
z?*k2|h=;qD|Lqz^sLq-EY0rQPAOcUn&0muND0w4tL@OcX@^|*fKQa}{OaLj9uN~{Z
zYN#PYMQ=WVoSfxgJ5X*b9Etl&UI5V43}ucn_7Jm9K_Hl%0Z-ip4of-%$9hY!SX$XO
zkUYQ-H$=~Wy&KptyH5O;@-N=vQ-)Fxrv<#4P2ma-R4@gizgTemHCecsoVJsvlq>Pn
zTQseyI7LArk5Kv3E@<N=y4(ih-g2PFOMbSW`?nk4zLs_zjE83A?X%mif)(&0B3<_}
zStz}Fc{>(oClCk_Sm$_Kf#?mMa*!0L6CyX}Z>~?4jCOo<{4T!D<1Ii&Pl**2WANV}
zQcxztfKX0yh$syM^Ac<rILGxA-!yOV0q%TV4WY=T!_SZ7fCt`puVJ#8Cn_(ZQ0i)J
z?_&N&@_M87niD!P#w`THnd*TS_OICj;u0u#dDs$Z5}ElNiB5-{0yG3_P0spt7Quna
zc7GcpAL%ZpddvYE8Ug5szCB=uaR-1_c0(rv-6;ay911)ET2%HFlYlc9JL?j*-<!Cp
z1XKJ581W=17i5x!8{mGpnbe+h9?z~yiiCmSgx1-tZd&qC>;*|MB6|sOeoRpOQ8(lh
z?x73x`vm-vF2IG}1t!KZS^ny;KOH=lfB>X4IXH$!ehGO=bAza&Rs-8jG)+Gqj}q{z
zY|gODz$7NVbBFJcx&f+m%4Y!SJO<DKP5*8Yih7>~%1{@e9qfi`&_P4G1gHTeZz({<
zfd+qqJA!DFI-sUm0xyC5FPu<u#nc|&fW7EFP_`SlW}jVC+}Vz|U4b>5WXG%L?qVnL
zW3D>}kQjau*xwwMAPy=um8v-R@+a%wN0Td#>$8!-i4+2pWs&dh8it^7o24`rg;TOd
zW4z*nu#PM-HxB;nZ0M#~2&n`dSLRj^_GWD@(cO4KL(O&atV%h}>5vI57+)fj;VkCS
zdUzf6k}Xc}viFaNbmwYmhUInSM(*mS9*@PAlOP$TQI4na!{G!l$JOMK$<pUqA-@-#
z86tE2R`1TUBb9Wq5*$OwaPJ3xpeP=IXb3rEzUTe4sY1lMk^b=7`G5;Q>2123Q+f8r
z-0Q=_Juo{e519^nq^|jG%6f5ws>hD!>Z5(=JwSg&13a^{d=0;#fIW=H4*I$>3sQfV
z3Z2c^R}Mi3a5(_4-Dj)0bg=jHg?oFgfG6vMGH8;U__^ra0IlvVP($9n{wy_p>PI*o
z?O@NQKZJmkLf)3gblc6;fFS<{Ax1EnujbDjZ`K|MVmW+`OLB1eg7L}wtJse);>A$9
zOVeN0hDrbg?Zki><;uhM4vAME^wmlB&L>-2HUohzC;y>OgGcNVY%`wDTF>UvN|Da;
z7{S8&mQd%q$Q3-y1d1o%cLt-=>LTlemfgn>?Yuq)$v@b(-0^|0!E1WJm<(U?)Ku>j
z=m_;Hl%e3qCV-oGm;S8(Ic8@_FZ_w_Xb<voAka!0){9(@r>%QH!>`9<X-}sDF1C~=
z)M+w(OsziTr*KsB?Rby)E`m?qZsvce8B#7k%484m6i4IKI0!LNU5x0{n0NvuZgSi_
z=t*H0Na}vlYf)T1!O_OTXB`~WhPobOJ*8BkNlWGrut+3#%~T$|Y)WU&=4bhP`U{AJ
zfp78(z>wa20w&4Vy@TAFCK|eVKnA@KHg!!vNBrYX#@B7gCBP^4v^&NNm_`)c(~zhR
zsR?<Z+scv#bQ^OejwbT>BlKX*={C1J&NIhJg%Zp`UTet@(G2gq-tva*zoiR-0WM-F
zm}$VeUDJRK^E}EI1NTaqGH2|76Ptkbae?g&`w$3n*eHyUCDUWtJWxaTj{k~AZLgNm
zkPu$MHzh<g<1}VUh@8f#n$-0o-}>^XG|(tTEcpgVXX*p5F5QXQkV0=g#%cwiubs)1
zzT$xh0d>`<^R8wvnO;HZS8!&~WO0IqY*}7l+6R<~E1CYo3>!pNgQ1T8Fl#cIG;~vW
zMji-G|0Mev;A32QzchjW#%I_qhj_$qMNp|`>>@G}WwU9ZUlMr6AJk8YZqoVsOT!Up
zhE-;|A;)~TU@P7}NOHj%R%nPhU?eQLwlzb}Qjm|G>UV*o$Iet7(zpjUTnDrLyPG{U
zZpr|xny?L#bYdEEDB^n|l`RI1GNC(?>VUjh?$i4bAGB)ANrKQExm96fAP%eCunP9G
z$_kWT;YMdeZ{jw;^yv4RsLUZXxmwrh*!e}7mcf1iHvESYVAezfL$Mk@eY10O)jE#)
z6We$<WdEIXnuWB60TgSA9&fwEA18Jmv`X@ml@)h<1VS*KcE$%8YB?3ah-U2!yj~4#
zxX1emWb7*kUf`6LsjpA@r9E=uBD<h~-JBP*NgXQ7tCA=6UOyA$+Xc-!gUvPtguhE1
zfM_FI<1>vTCX~4k=L4&&v~_TtLzYKBfdB59S}Elx++FQuH0Q+fU=aO*+s-5kqOHI-
z^cdNmF`X8cLLsl5hWd{JT^h_V=w<bUK4%Wl756|Pkoz6nbN4y+eX3<7fa$|Vo<FDe
zCbm&}kj5&>hwh!6QCtGtuPks|3Hv=vR{Efu+R3mY=+YL&WPJP>mL59;=bCiTX>^~`
zHw~wR(Oanx1)e~8QKkl<Br{1pZEoqx&mr;y$DYC2!mvVYLiC94W{(cZ5UDvfNWXdx
zD2P%czt-)Eo*0aWHLq)xa*%Te?5J+YN_uIx5~{`ab?b6YBEz2D=dlQzKFWOE1_YD(
z+SQO2m<3bUpw(Kc=lNCq8p=>7l*gRRc*bTdFV~Kfep`>rmT&Q#ct<io=PI?{aG?9~
zA~ir#i*zDVGo6YEm<2-Ut-7rG<Go(fry&Yc{U+EdijZtynHjU}xgSWEBOYMk{XV9=
zXi7d&1Z@nNco!88Q%JlUgzOCSnYvqKRAicr%rz&!`aKNVciMz7H85z@HJ;KS;VzK=
zf_XspH_;_1!_f#&grOrM75qPE&XMrue6%VY<7a^hQdlfhW(wy^1aTd(Be2~fm!Ap_
zaG|(8vg&4vMhRkHR>IzK&yE9`W}|7YMh*XQ0wIcn57H!ll_K~LaIdz2){|@N!#)1b
zbTJhzSXI8IopC+@L+)d*eC7&vWHJ@tPcOeEIQB%09UYO+^V~7?1!fNiHRtW(`{)LI
zpxmfyZN=9*p`m~~*nhcz@l{|Br!&K1kUvm6RH=VZtZ94pX|>u6hZ9S4X4WE<L^!sY
zB`C5yzo=lYK-d^Ca4V#d)7(+!b4Om;Bwd%!d8$Sq<bS{BG~SDXd3c+rgOW}kTF^3(
z%xv9PD8APu+$zM?Q_g??E!cl^9~?uv6_9qyPt)?V!#%P2Uyp*=vGy%jX6w5{Mt$4e
zw-p}yJgKJ~4jH%%9h<~Yf6mt>Xaf3Rj=yGPMQnvCXBK(LCFudM`48=uYgE(VQ!oJq
z)5!@8MW>dt71xuRSJq$N8%CB-zaB1e!imG2<FQ=!!eGH$ENj)CL?ff0l0)N=y_=dp
z02C)7Ors~Z4n!48*+w66g}#(;N>8iJ7%tsw<H*OXE;=h~q|<mon%|N<5!MXS?jJR0
z6RXpw^CckUDp@TB4Qg*uIJrJ8LX>>=l93%LsB)wf`~D>{2-j7J3C1&FGXD;@><x*v
z3ntSy3LE3`(jZfRT=j>(6#y0|XOcZ5KAbm8H3w3SYwYD?l{)yQt}ve(zW$oAOBd-u
zb!0}o&u80o9aN8oFY;-miJs~tW{F6qcD0UoD(!4#7ADtcn4HKfhj72TpGhduD+Jxk
zktK}}TUOp9_O42+<d6OktfH*B!lH`9rQP>4VysJ`BHhAs!+*?*{*~<&ln*IQ&0EkL
zGOU$RxiHF;H#xc4%JU$vxn-tia5i(QKG`7IfF$GGY0#H`Smco9Pb`wpY)DL13erjy
zU$ccB^q(Gs&|=`m9F(oP{R(q_KczMaG0|vmjN+4yKFx-HIL_kCx_ZxAptGd8JjSeU
zn|2rP;f5PEkht7Oo*mb{Qq7fYo~>5C3Vo}nMUC^Gxm=TdI1HWyV}ke!#adC#<h6jx
zCCD8s91d#^a;+2+a|G3b5QX#g<(8ZCK`q^<+LOZM<u{#&PqhKxq;+nNMlwC4=WMp6
z%yCYABtrJmm+2XBHN9M*3>(T8T^L^+z;m*HKlDU80khxH6Y2Dyxy}XC=V_>qO1}%Q
znLe3DdXiX~fGUZk9~0|g>SJ$Fp@73?X)Aq4@hK9bA>3Ot-1_O~{uDCjO5$b??8zMT
zh0nCuG6k5*fmH){wN#|^hMRZDFobKz87NUQKm`eeNXy<UL`>m)&rZM2$9WF`Q=L+{
zdn_>zjgX(Yy{T7g7386GvN37unKN5T<!@`mXQIwLWw$bMbYqQ^CG#1)I<?*QWy~Z=
zLvkX1`|~|lupDMt{X1K@Vi0~J4$DMBxm3`M%}W>oP=IWD75gA9bh}cQ`ioN-bhDJJ
zo_AlKHQW#_tfMa|)=b+X)MgHmykNOPFfHwe^L%M;PH;_EY9^CAuz{9s)Jvoug=Tyv
z4)RQM&)Qpi627of*b<N>X*dR$pSN!%M9NWFBE37uHEje1HNu4Vaf0}(U1WVe;Y`Y|
zA1T9XFtNOr7ay6__6jDHUwyV3Y5z)A2_F=YL+?ecD!*rc0ds&+@*NGXS7(05^U)_*
z{(>vSJdS*n6WrZ-1QJO&V%t`Xo0Qd5J^H!n&0WB^Al&%mVd6b%!&WhTP&sqWwU;Q(
z2J=^{@cnUJs-DBg8A{arukP3%y)sx)K3<mQKcHSJl+E;ZiXVYE#{A3yM-HS!7K0Y|
z#9}*fy6$(FJz<aYGiI#!t#d(M4w%drX-$c>0P&2hsVgXRPJZGA$^3fnVOz9Q5R6to
ze_$^ZEMsa4ZA6DodXPB%_)A6<!Mpa-@za<SL@4VmMmy3Rsd9!IdcR<=VVE!+ck})C
zCEPDza`dSj1ieWn&C-RD?JIJ&cG6#%+Am+MDK8~H&J-@bG$%&WHE>XCC)z(sN6vJ)
zRzR}(6vKGLOn(MUh~`5Q*v}$#T}vzJr8kZvVf?~k{DN;D^!&169nH_`7GB;MW|EGz
zz?#yxG2ICE_kZat*jgx?F#oRdwc9#ZuuH16-fi4Cmrl|5^ZL%z?_fr5`F2!{(N0VG
zc1vu<sNBT7ToI^GE%Z$3t^ou`zrDghmK0>vt$C^Kl*W>nulh-l^*NhXVKQxyX`bis
zOQ*JR7GbneB%=2gQ~1dDzO-s4K>YOCnKBC=;wA5?ra^Q*dlW;E&WO?KS?_RkENLgQ
z_Q1euXll?aH424RcHyt4#XIZo&bbH%xTNVusooG`Sj;R+@&P!(MW!H)Q-=BIT!pu3
zw|(5DS%sEDC*~Ijh<p2<rl1ba6?;frGmysTk3~P4T2N=RzZ6#oCxCC!woxb;bR|W3
zL^#>G6_rjRb#CoXG^hR%fZS3DdKEWh3`tS?A2XUi`tXxa^9ya-<CtVo`;@Qr@$%1S
zix@nlq>(dQl2(APGFr@SMW!|Q_K^@GaUCgSiVlgDLhRUm26w>=&7>+Jry)&$TnP)|
zs~*gZ^J>+qG^yYIITLjZ%}OJlw4>JWXg9uhhkZ-Cqq!va7h_<<58Lr~lPI~gp^_&Z
z&pMhaAx*4(E<``NXH}CSFZFh=k}y&wQ$_yE<UYV>Kue*VHS>K0L{$JC&r}7q^)um^
z;@S6<cQ5v`D0hz^Mxk(^z^XRL7&Xz^aNkqjB2{`muo8Pg&ndpiQ`W;WQuK-{se$%=
z+5J%VAgr?Ym)6^W)ouHURQK~`#L(l4Y}A}C{+QZ&=CfV6KzWH|A{5uo#xph3uVY+w
zhN3BuW*yBbMa@7TPL+C|;^wzyw$uA1DADmaDNSn2ITp9-_K@7IXAawMUms?DN%}H{
zbK)Sp$58uB)f=b@1C{fdBp&K+rHCBl<}jPyU#zu?RvAvyN8<b#hn(-x`At*{wd8|&
ztEc!#&mS7Wm?{2%hYjgM*Ac|I^4%~Htq*2mr&O3KqcvgoTiBS}v%D2R$C-92C#~ub
z3#LmH?k4`$%YN7Q;TwXqL;f%;{0CigTrDOpo0!ud&wb)O)CSBv%PVJwJ;)zbJ<Os?
zJD+QY!VN@gYS?=!*EbRGUh!@E!BnWl_<AUeM|zrI6#uwh1IBrzEOgq6F4GsLX%g)+
zL>93=wL&#$H)Gh%g!GV8N;so0L}JQFI3rEliqc*jN%swzG+IL+4MlPeZfQl?q$F>@
zHJg=oQ&2Nn0c=k7r+vO1>&LEG>n$cH)eC^hv&hWs9l+*QOyPO=g#%gpo3kraY^p1e
zB|qrmPOs$L>r0XU5$<o&;r8b>d&wdcx`-y#MBBN-+jc31nRPf`jS2d3-Y_262Q7Zh
zrR`hpqxai*8Rgb*Dm{0^T{Z0}UQV8(ZH8&I-+vVE{5l?C?@-3<2os2g>4n5}%5)lb
z&)vN*6A=~^pA-a_v5knpsE094`Jj<j$qVM>q)TeI-XD5f*wC=Pwf+GxF&8(kI*Au2
zJNOQPqK{PxwBi5<u|@A5X=1KEr*yqB*X-MIVBfP;R8wDq<tQN+lacZDUQpv2f3!bi
z8MpE0r{sE~bsSxmE}~gEO8>ZWS5q$PXA~{?al9_a4`bt3mhQjHG54d1@SRMH4Q$Wp
z-Zr~uG6A!)P_fRhWv@uZQf`!gaH9r4O)k(9$Lzbzx}GUL0Mdww4Sf^C;5rty$bE>I
zB4{uH{4%`-x6CQ<+zE@0gxypBblU4{X(CGzwkg(S97;TN#}8OcZ*+YK6A{7El`1%?
z0sFzF?{Ty4$J*EB@v62SbY5)HREUlYVx?(0$Le+xW^tm&mUhHR!x_r7k+E9V@LseX
z;#{={nF@UfeT!}LLTg7R#PfxWSPYE}BPnUP3_<V;GlqgAU2SZdMw%(plGEq*tDmD8
zik<@s8b?L7S0&ZxlbXRXJ%<gN1RY3B#*t>`DQd2Z1a|tN1fD>7@^!(zFJ8P4gFkQT
zSkuH!6;t-YdLC2W!IdP7Fx0hTk@Pq<ZK+c=Z?=VaN1uT(__*WgEWbtvjmZTgu>#xq
zH$Cj|!%wZ;k^%0A3tQskH!G_jY_q)7nH5dl62-h`pDvyQdQfcJC5ljckvxa9R^iiA
z9)TZMj5T6wVKszowWHx<9+;kalR~wVm9IYXWSkK18k*;A7JbXSIKVy4DokUK(nQ@f
zJdR7E-pO6hzU%oic+lN(FuQLsuCyas8h#uRlx{ewcHXx6(XOn4`Xzx;Thmj~v)rwl
zBM|vgm-0?&*BF`8?3rQ`AHTp4s*FXJ-KGSYVv#|cuERQ!<lUbY8LG+nKZRZ4^?_N+
z?J=Va1@LOI5JLrW*Ux)W*QZPLj$*ILWS?B~3>J@7+8XmDH(|S+0karyn|{o`Rn+LZ
z`&o6)WK!uJhhc@EzldHG{K9<5njgbRp4jn7CXI@P3B#C?Z!0+hSC!*-ugj4H!|wL?
z#*Si)NZTe0Ti#$FhsOy+O)g8_Prl`5t><gEbSjEQ{u5EUU=ItS8}pAGy7fiF`9Mra
z&1H@g!;SWQ@C=8BBnD3ynJ@woOZbK|jS%N{<v%5bhXh0BFNc;gXO_LO<~YZfs$5@U
zJc)h7?y8Q2mwW9(GXq&5qQ=svQRKaWL_S#>{7B>`_0kL}^h{x|91UY4AAS?j;t~8M
z7WG*MU%AWYmd2t?{^SV_&pWbPhELDPisR~H<Q^K2pc>01F!m1Z&z#RcE9}yH9^!JR
zy7qPn`Nz)Z@G@@40`;`#EMbPq>hQd88^l}2^5yAQJuj37*}Jf*dHCD9QOQ0MxX}+6
zIvii|BBN1?E1U8tn!Ry9SOHDPTHso}oXqeyVtT_jw%S2I{6=YyUc|T%ex*!4xwVQR
zLyt^2MT?|o=*aW5{l-pkI7awht4OmBI;&UxM>v|!aX4K71s0<2foqyM3XM+Qkk1^B
z`KWufVn8`O0oeuhLE>o=DwABKBtzoe4e#ja%Z0_AXesLNQ!9&48?OavDG26dO19zA
z7hLW1<Ma>v$~(i^Obk~E0#@ufO^KiXm?L_YMwvzN$axeuty4$l5sqKoMmS=n>8ViW
zZCVR8%lI`3K`$X^x9z^vi_2S!-p^?p69acnpmu*_K;T%!^Sk`wlIxPiuG6XBL1*-e
z)H)-m*DRs3PS!o5xc}gk=u_0&x*|At>TB3>U3Bq!;0u$FA@d#{(TJVa8_Bv08ku^V
zF4cm;E{QBb@@WGUdLD_kowKk~^)05UK>`A|*~<@>)3P;ydm!bsk+)Ve)$V$uSzu&M
zSV_Vl${>!0)xbvKHI(qMha?z7#*_zMMRw4dF=cs}c6&~nyQ`Z28090^r*;lhO-CtK
z+BX$*Ne!YfGX~Zo%ddTm0?+L=?;jE|$WiYzX32->T<^q5T~q8AYwV5pIUHX2Ve~$X
zjuT}_e}+PNX340wiXLtf7Fzd2MG;0#-#6hiED*ibr<Qp;-fZ!h=o!59z&_n!(EHY+
zHm9hvKi+dSKIzd|Rl?gR69|pq{3bC+D_j}(mBIX{(Q7t`ZGX7{uqX1dBA0x$+H{u?
z->SQO<)|^`F*C1oHZ>>Ol*M<YMyi(H&14>_A*MbCA13gec=1{GHR8@|XTs!MAbhh%
z2O^O45Z*2;4wUcf#A=@7PkMi@rkoKGsEnm3s?&$(Zg40uS#Q#erha{t)X0lnTsJC?
zrh{g%h_PK^nITsgQ~9VFsINNEv(q&ESaN+Q8Zra2PFHl@a+Zty0%$$BbiPa7dLScW
zF;>1ieOOPjHyWxJTqqiD-`Iw>T__t`(m<zluQi#00P22AI7QTY;1`T%{OdDf4woRD
zoYpp(MdRU@VC<%n^W<j2CP!n$TW0-8Jk>0ARdQ8Sogmj2B%$o4{LDocFlTvr`A}yU
zLT10>Qq-5`Tt>uoodxQJB5!vNm=`)$C2k`k)K`&H$6!%qqz-3mg}E=EQ7~wIwv&xy
z;K9NYYo{?-ROZj4L`LDHv(R(?mI5B?FfT6fo|aK)h{-;qMEkjZ>lA*7hC~m&S~xDC
zlabGMJMhCp<WWuGR~*L)p&O@|hIsYqlrOT;@K4#@55<1Yt=m*YP1;ivMnGp574pZK
zsC2Ox`&K$ej9;zOh6KN@H7tpLG&Kl2Ox7``R4&wNK3?>w;qj_h-Y$6iHCeKxvvUzo
zRf;(OyxEo`Fvn)JP`kROrG!3H(c=fR<JBj+LLRKnk*cc}Iy@xV5dGIKUZku<O$<0Q
zx|H;kB<w8imFOt>-)f!k83=C&y78>Z{Fq&i?@wC)s60jJKFp0*(U!h?p{Gve(xXxn
z>rm`=n=R5HTWm1GhMo1@CzNo1)>(gA_x;^CIlH?e-{?<=lGt(*&001kT|0*QBc4-)
z^$QSxHAcS~aI9UG1shQWB7ktTC%5J4dD`C73cmQXTP5lx@;HiUNgG6jO|gu#84JrL
z>q9J0=!+1+0?TVbDt1M-sT*l{`chMni~{5C#a$$%j8&w*u8fH-UpTE?(B~2V=aMew
z#hi=*OWm)`$_{~q5r6TEX0&C7WBFX)3$_3tQAPj3M!t>0MW>AOt>8VZ=k!Bi4pjp`
z!CT2$)>^mZ`72_6R~B2b+RoY$JTsM;0ftPZ1g(is@4f2T4<ptpyrvo|$LUid?|&-Z
zCClZFJy|@sK0n(mb?p98S=5M(ZaCQMvb5#4jmE}+8<0A*%F*cEH*K)V`)5$`;hnN#
z^(A))@la<<(Dm~&(#cOMPrVa+D(|!@A&SC8hCW~!xZr!fN_MbKk6*?>5<z-<N&2yG
zo`@+7jsFM32ojmnLS4Oc|4ZeO4PUq_BcjVaN7OTdZ*jQy^*2t_$A{U+O$W4Yf&_V=
zH$&1w-KKHHvPK&GPA|N_iJp0eKKM31)+U81#_CwiPQP906*P>G79c5jo$jpRpQ7q$
zx99oJ)&(V(Q-tmILiOb$TITINN@o4%B6@yv-cp(Eu7l#-5xx{c6eP|GTALiol}>1s
z*MvmheF$@FzhBcrtCAJ7N~7aW;)kW1#%X1ixQ%#<OuH`t>q%_S)(d{ouMar$PMoS?
z@v?MYMz1$7i2NS>a3$`Snr1;NC;G7L2@^rwhbe7cnV&>lv&P$0Nbf4<B0{9;U#jeI
zcr3Z68<V~r{Tj?!z`ozNb#h@wu+Sh*hf^0LgK6~c3G!h0XHD$MFGGSn4`ehS3}<<z
z$oovW$znhr#J64p(yv540%mw`2bQpTez_)$k>q6{i`tOkBbiwXwO?QhSAIhjyRR;(
zf$zJO7)Xq=*g(_@)lFAhuts}nuz8ZWk$ZBtR#!X2cT>>8KsRG<yx`S4W!S|m(YCAM
zszYU~{O>vKNMtIVao=*Ak56_cO`@@))_}MP_N!uH(E&@3XZ(=UjN>WWjeJm@ckuI6
zJws7UvMw=r^mRSYL=Gn?v&65$zp<kLb1SKe-xoJz*{Go*3kICHlQZ?LJ4kDu$jUWe
zz0IxKR1~t_k*(%;iE)H89VoI<xr>EYe-<D(kdQUayGsXj!fK{#h9V8s_deepzPI6g
zA5-OlmhZi3^N_Jy>$7z~p-N3MW!qR$L+-5JKz9*771GA&Ibj_xUBi>GRw?b3`J}>0
zk~|Mirj9&Ze1wbRkN1gl-Q{Ha`ySY3@$xbjJgsSZLPzwXbzeB*=g~08%Wdc3L=j&S
zA4=$1ZI@gL66~fkt#>7o<e%f{mokI34q#?n&_>|~Ra;}UZ>v^Yqayt*Ke?-88g?za
zQ7bWeflqxO)-#f3moJCfcl?!voNIEtSJKrDDzsV{FPgdAHT@9vGBi;V1Z{>|{#o^i
zhL_GZks~I7SI>WOb3UQpQG_*QGpv3^sParaXj*^tMm+f!<8_2|+_wU1lc}6lqUe*I
zc{;Rbvo^(zous05GSydtQ7Ng*u`|3H3R#xshQbp*1xXUQnd^puAkS7TY6}J7<P<_p
z=8=_7P0oNa4)I|0PTtc4N&!3bs3<ko*htU$NL##0N@^4o<XQ2~s`syf^;RMIcH0Yw
zLWVBF@uKF`=ZYp6V=!5|=Z+4t)q=>F#)-h?vGJ~J7Y5;c7rnbFA8D~bcI9%OlqHE#
zP!}Brh53|hc4c?+Qa9o4)Zi(%mB$O`M;jpiqJ+@F&{Wp6A%MUYO&ux&P0(@M22;&k
zJ5Dd;i<=1$&zRMFAFRahFbg|<Z@3c^F{Iji)!)F8#Aqefko9!+Lsm&hLv;K~2GIaG
z^m<~8f4%f)D!S*G+lAGM$F(RERx!!=M63!ewqiK;vvt4qqsx#89hh|>E?U8=Yq^RU
zrL?hyiGj$UQOt!cJ*efL#NCn@`X{<<t36?>dEt&q{|9F2suv88gsxbHt6sR8&7qEN
zb#!5DexAt_2rH4OGZ%4z50~H+Kl6Q|H!Q!Hy5N5>BofY5vJ=Mp<9+<r3vy$M&WakN
z8uks2NuEq!GJHW&tUI`yop_@848)S?c_i1<X<wa1s9)F|TSqCReP7@qE^PTGA1WE=
z_QD~&m(+LRc!mspiYuyJtkf(Q7j1Z^l@_u934%LrFHp5pyzLp(Ux)vrJ7mw~rf%Y^
z-sV6s?b~K&OQJknjD0Rlf1DAnf(ZAa>dUydaG5b7vV^eIl3`!v)G2wRLdw~rIo#K-
zaMT!!Ic%Btb!39o!qPB%)ryNGux~Yrqqi^WcEpCWedIQDc2eqBQsv=aw?$YIl+5a@
z<JOyvEGxTx9EzA~c^}-bcaw(UTFER^7W}S+Bm9cT^N?_gD%e;Q*;gL1`L-Lz5McX&
zBC)f?j_IJYI$VLVp>Vk4PR!U-y~(!i<^@!%45Abx`1Dh5!YMSQ#ni-&EO$u`wu84U
zrj~|<_;+uA6#Z;2WIq<!h8PmBXqZ@i-(Tk%vh01YfID{>Crdjd<$@#B4lD9e^4DbY
zx$eD_jNhjc0n&4t5~o4h1dVc$$$Lk1C3+>E%2Y33`QWX@={+onYv7a}T{kcANz<ap
zs3d4o<=!TBh6m@-#oZbl4<62eg=^PLv?HyI_G6A*Bkm%8TN!D$kn~JgUQsG{4Rn^D
zlQ|5z59TdX$YSLU$z`D4L19-d?3VcwtHCwi^Xtn;W1RTwy93NE1tKh{B|63AT2<{v
zu4c<Z{?})#OTd{#<Jj8o<I$*ohJ7WZ_qC{R`fKC9V=pm>bmdO05`V0}QP(e1o!Ig#
z2saS~f5tqt0r)8wE`uW05yr!<_{H@lsk7V5wI`}&RK(e@-0{ra$3M_K9XT?Ri4)cS
z#w@^wd<uN~aduI9B-5uQU9Yv3D#B$xMLC)$RDYt7e|X7G{z$VQ?a7?IO}&(!^b4L@
z?V|5V9|Q6`s{(Rr9x|046z}Sb^VMNzcAv?Js~yXFjJ0vDB;+SWW^oLDfByhq{bH?v
zBy1l@WkfbBwUvr+mif1&dO2px6YiCNI!K%GfSUcg+e9sp^Zc;#zow-v3mvf2-j5To
zm1X%-ZIi9Q=N9tp3AgoHo1H$3_b9PmH<n{qWc7Upo5+sGl4lmZx>NDO##B>oYRh=+
zPIzUTZzbLy*(+r-dp}5*d!Wt|D(jFLR`_k0uut=}+4tln+TnI#DI$DI!ePwLQ(yC1
z1>3ABBl|$P>0|7q&^$jI0fPtW&))mStpQi3e(K*<dwqC<FODWn@JmaldLkY;j=RiQ
zzr*Qy5xQpa4Q1+SnsaNM$V}?*Z}>9`#Y77*PTInUq;AB`oCCZ4Ms)_sHHsXKCLoxx
z?aY$>@r%18A_;@Rq~<If_qr)p_$srO`6Gs(5h|sTjfmNel_o7%SrfmL5#m=&3IL|Z
z!{={~)qwD2yWFc5f7U2O`;NrzowIFS*@X(k^m@+Dwua9;Dgsg3l!nF!>?Hf&gUmke
z*z-b=WI+J#qYCvf%Iz|NHeYq)^I+G&54))*0p0|OG@9JWGPngVVA*7Q5zo?T53<Xc
z^~EZ}cu({WLr#;Gu7MB?eXL(^WgnzQHJOiecSxP}SB%Io_0-{LR(OTSRkVF{{5&xT
zQux$`7ZHZiL>d>7-#ec8v-|w+kSUtr1NhF$@jp6IzbELQUP4e|FnLYFs#WCZk=>X^
z`Ts!T7NSSH+Z%T$1Ae24-?uvuOm$2u?{5FdoZ$KIDhAhM`nE=ij}tM{@D$e3|E=WU
z?A!4R-_vXJZbkm@Ri*)O@jN4X=b=|rvqE{xflCCGb%F{5fjw^pMzI^0r5Mrpf6@G+
znffB;{C+aifmWp0cPRVoZ1Sh&d2nkJkaWJYyuhhBqW#7F-PNv>9xWRs8zoa5z2@lV
zI^N_Y6kn2JayH`avdNMfCE$Ol-!cEb1G?+3E1tW`dP7r++Z&u69=Os>`2U$7)r60B
zOK=^ijj4l$!8r*r6JX--NYl6ZBIy=W{kby5jJ%};)-p{ne8)9QpY!)Uzt@WCV@xKm
zlfzdA0ksB#|6ZmM1~;0u-rVy4v-OWAfX+o%0?#aS@<)dz!=KmSg-VB<w4Kz?|6O<B
z)mC!!ZFeh0syd*a1J;)V1X~b(V31Z1j6InC?3BNsP)Jbsdf}d>?>&eG`13&UoNNZr
z^B-#8WrN=zCrLNn`u(4GmBA==IH@+0{d@0mG{SM)A;eQ;KJ}R6-=@o$%EF17IFYBV
zz_XSytE~R)38snQYUV%R?S4;>-(wnxarpTqXqE`PA@%PlgH}x8fp7PyJ1HX6&5^bP
z-~GGA&dkV|bDTdm`hNdQAxumP27?VM$lTWiJC1#nbSZK00GM*dDTX6}3jEt0Q`q2F
z&0d)^egCxtJkTp1blZK}tN(pV8hUUn12W-hCb;TEa`nG03|jtt^5FMkEguKyH2!S~
zLGU#3qut?a?rj(&bnAj2axozQNa@lcp2ItiJ^ytO10PWnxhSUoo&VE0H{gR$cJA55
zLBF-nlrE(Mk1#F8xTJ%@Zf=<B+Redtp+Vn;0(*^!sivuykp)*^3bLv)B@awP{vUt@
BFv0);

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_geo_autofit_v4.png b/all_static/images/migrating-to-v4/migration_geo_autofit_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..d0d41d1a6628870c23f3b9a101b776dbd8d4c0b8
GIT binary patch
literal 87755
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

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_map_autofit_v3.png b/all_static/images/migrating-to-v4/migration_map_autofit_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..d216da8e714ff8b8515044733cf8dae15e7160f4
GIT binary patch
literal 89209
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
b&tTA@O!uLQQySy45s>o{H;31D{t5p9xiV&o

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_map_autofit_v4.png b/all_static/images/migrating-to-v4/migration_map_autofit_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..3eda2852a175ff9be6f3d33c0335dd3caff6c9ff
GIT binary patch
literal 48538
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
D^K-_;

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_sankey_v3.png b/all_static/images/migrating-to-v4/migration_sankey_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..5ed16c08260d6a4d174738977f57be79cd9bfa16
GIT binary patch
literal 69800
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

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_sankey_v4.png b/all_static/images/migrating-to-v4/migration_sankey_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..833ca8c786d7641eeba4e55b0b1ea111d1e5feea
GIT binary patch
literal 68596
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

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v3.png b/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..262ee58b9de9724f8583c481f83d521dad2be23e
GIT binary patch
literal 59214
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
O0000<MNUMnLSTX@e;sWA

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v4.png b/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..f6169a6713def77a5b5544c67c79f4b16346fa8e
GIT binary patch
literal 56442
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
FV1nQIB5eQw

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v3.png b/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..2b97f9479968b9cc949085361b6ece8e87711072
GIT binary patch
literal 62430
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
N3NotFHBv?){|90jIV%7F

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v4.png b/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..70fc6d82423265f63ad7544a16a0598449dc4a09
GIT binary patch
literal 58887
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

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v3.png b/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..43230aa4a55e922e5dd01e4e5e939e2874fbbb82
GIT binary patch
literal 29802
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

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v4.png b/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..66b5e6c25cb4b87ef9b281f56f7d3ce9ccc4226b
GIT binary patch
literal 29948
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
W?<}|#%n#rb992b4g#vkW;Qs;Qad8;{

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_tickmode_v3.png b/all_static/images/migrating-to-v4/migration_tickmode_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..e2c582f92e4dff81fd16592591cfef4cb3750311
GIT binary patch
literal 37078
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
E2NL6ob^rhX

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_tickmode_v4.png b/all_static/images/migrating-to-v4/migration_tickmode_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..d18bcfd6694d4691b28df26c326e3bdcd4df9bd5
GIT binary patch
literal 35021
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
D2s5>7

literal 0
HcmV?d00001


From 7141949a50e5f0a1fe0a16d121d454ee4fcb2b73 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Mon, 20 Jul 2026 13:28:15 -0600
Subject: [PATCH 05/25] Use spaces instead of tabs

---
 .../2026-07-17-plotly_js-guides-index.html    | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/_posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html b/_posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html
index c6611aab2..85859b6a6 100644
--- a/_posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html
+++ b/_posts/plotly_js/guides/2026-07-17-plotly_js-guides-index.html
@@ -10,16 +10,16 @@
 
 
 <header class="--welcome">
-	<div class="--welcome-body">
-		<div class="--title">
-			<div class="--body">
-				<h1>Plotly.js Guides</h1>
-				<p>{{page.description}}</p>
-				{% include layouts/dashplug.html %}
-			</div>
-		</div>
-	</div>
+  <div class="--welcome-body">
+    <div class="--title">
+      <div class="--body">
+        <h1>Plotly.js Guides</h1>
+        <p>{{page.description}}</p>
+        {% include layouts/dashplug.html %}
+      </div>
+    </div>
+  </div>
 </header>
 
-		{% assign languagelist = site.posts | where:"language","plotly_js" | where:"display_as","guide" | where: "layout","base" | sort: "order" %}
+    {% assign languagelist = site.posts | where:"language","plotly_js" | where:"display_as","guide" | where: "layout","base" | sort: "order" %}
         {% include posts/documentation_eg.html %}

From f4b10cf16b6b246c7b925960384d1fe22a49ff72 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 22 Jul 2026 16:18:15 -0600
Subject: [PATCH 06/25] Trim down migration guide

---
 .../2026-07-17-migrating-to-v4.md             | 945 ++----------------
 1 file changed, 102 insertions(+), 843 deletions(-)

diff --git a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
index 383172ad5..39c83ce0f 100644
--- a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
+++ b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
@@ -1,10 +1,10 @@
 ---
-description: Learn about the changes in Plotly.js version 4.
+description: Quick checklist of code changes to update existing Plotly.js v3 charts for v4.
 display_as: guide
 language: plotly_js
 layout: base
 name: Migrating to Plotly.js v4
-order: 1
+order: 2
 page_type: u-guide
 permalink: javascript/guides/migrating-to-v4/
 redirect_from:
@@ -14,181 +14,69 @@ thumbnail: thumbnail/mixed.jpg
 ---
 # Migrating to Plotly.js v4
 
-This guide covers breaking changes between v3 and v4 and how to update your code.
-Most figures will render without changes; the items below call out where output
-or accepted input has changed.
+This is a quick checklist of code changes needed to update existing Plotly.js
+v3 charts for v4. For full detail on every new feature and breaking change
+(with images, background, and edge cases), see [What's New in Plotly.js
+v4](/javascript/guides/whats-new-in-v4/).
+
+Most figures will render without changes. The items below call out where
+existing code or input needs to be updated.
 
 ## Contents
 
 - [Minimum Node.js version](#minimum-nodejs-version)
-- [Color library swap (tinycolor2 → color)](#color-library-swap)
-- [Chart Studio APIs removed](#chart-studio-apis-removed)
-- [Mapbox traces and subplots removed](#mapbox-traces-and-subplots-removed)
-- [Country name lookup (country-regex → country-iso-search)](#country-name-lookup)
-- [TypeScript types](#typescript-types)
-- [Scattermap icon defaults](#scattermap-icon-defaults)
-- [Map subplots auto-frame to data](#map-subplots-auto-frame-to-data)
-- [Geo subplots auto-frame by default](#geo-subplots-auto-frame-by-default)
-- [Geo `fitbounds` framing for antimeridian features](#geo-fitbounds-framing-for-antimeridian-features)
-- [Geo subplot zoom limits](#geo-subplot-zoom-limits)
-- [Shape legend marker outlines honor `line.dash`](#shape-legend-marker-outlines-honor-linedash)
-- [Overlaying axis `tickmode` defaults to `'sync'`](#overlaying-axis-tickmode-defaults-to-sync)
-- [Sankey layout algorithm update](#sankey-layout-algorithm-update)
+- [Removed color inputs](#removed-color-inputs)
+- [Removed Chart Studio APIs](#removed-chart-studio-apis)
+- [Removed mapbox traces and subplots](#removed-mapbox-traces-and-subplots)
+- [Country name lookup](#country-name-lookup)
+- [Auto-fitting on `map` and `geo` subplots](#auto-fitting-on-map-and-geo-subplots)
+- [Scattermap rendering changes](#scattermap-rendering-changes)
+- [Shape legend `line.dash`](#shape-legend-line-dash)
+- [Overlaying axis `tickmode`](#overlaying-axis-tickmode)
+- [Sankey layout](#sankey-layout)
 
 ---
 
 ## Minimum Node.js version
 
-*Implemented in [#7861](https://github.com/plotly/plotly.js/pull/7861).*
-
-Plotly.js now requires Node.js v22 or newer. The previous floor was v18,
-which has reached end-of-life.
-
-This only affects you if you:
-
-- build Plotly.js from source (contributors, custom bundles)
-- run Plotly.js in a Node.js runtime (server-side rendering via jsdom,
-  validation scripts, image export pipelines, etc.)
-- install via a package manager that enforces `engines` strictly
-  (`yarn`, `pnpm`)
+Plotly.js now requires Node.js v22 or newer. Upgrade if you build from source,
+run Plotly in a Node runtime (SSR via jsdom, image export pipelines,
+validation scripts), or use `yarn` / `pnpm` (which enforce `engines`
+strictly).
 
-Consumers who only load the pre-built browser bundle
-(`plotly.min.js` or a partial bundle like `plotly-basic.min.js`) are
-unaffected — the bundle runs in browsers, not Node.
-
-If you're on Node 18 or 20, upgrade to 22 LTS. `npm` will print a
-warning on install but won't fail; `yarn` and `pnpm` will refuse to
-install unless your environment satisfies `engines.node >= 22.0.0`.
+Consumers of the pre-built browser bundle are unaffected.
 
 ---
 
-## Color library swap
-
-*Implemented in [#7536](https://github.com/plotly/plotly.js/pull/7536).*
-
-In v4, Plotly's internal color processing was switched from
-[tinycolor2](https://github.com/bgrins/TinyColor) to
-[color](https://github.com/Qix-/color). The new library is actively
-maintained and supports modern CSS Color 4 syntax, but a handful of
-behaviors changed in the process.
-
-### Color string inputs that no longer work
-
-**`hsv()` color strings are no longer accepted.**
-
-```js
-// Before
-{ marker: { color: 'hsv(200, 80%, 80%)' } }
-
-// After — convert to hsl, hwb, hex, or rgb
-{ marker: { color: 'hsl(200, 67%, 47%)' } }
-```
-
-A color in the unsupported format will fall back to the attribute's default.
-
-**`rgb()` / `rgba()` strings with 0–1 decimal fractions are no longer
-accepted.**
-
-```js
-// Before — tinycolor parsed this as 0–1 fractions
-'rgb(0.5, 0.5, 0.5)'  // → rgb(128, 128, 128)
-
-// After — the underlying library reads them as integer 0–255 (truncated)
-'rgb(0.5, 0.5, 0.5)'  // → rgb(1, 1, 1)
-```
-
-Convert any inputs of the form `rgb(0.5, 0.5, 0.5)` to `rgb(128, 128, 128)`
-(or any other supported color string) before passing them to Plotly.
-
-Mixed-format strings where at least one component is `>= 1` (e.g.
-`rgb(255, 0.0, 0.0)`) continue to render correctly: the new parser treats
-the `0.0` components as integer `0`.
-
-**Numeric color inputs are now rejected.**
-
-```js
-// Before — silently accepted, rendered as near-black
-{ marker: { color: 42 } }
-
-// After — falls back to the attribute default
-```
-
-If you were relying on numeric color values being coerced, convert them
-to color strings before passing them to Plotly.
-
-### Color computation output changes
+## Removed color inputs
 
-A handful of Plotly's derived colors shift by a few RGB units. Visible
-places where output shifts:
+Three color-input formats no longer work — invalid inputs fall back to the
+attribute's default:
 
-| Where | Example |
+| Input | What to do |
 |---|---|
-| Heatmap auto-contrast text | A `Jet` colorscale heatmap shows text flipping between dark grey and white on mid-luminance cells in the teal/cyan band |
-| Auto-generated `insidetextfont` color on bars/waterfall | Same threshold shift around teal/cyan-ish backgrounds |
-| Sankey default hover color (dark BG) | RGB channels shift by 1 unit per channel vs v3 |
+| `hsv()` strings | Convert to `hsl()`, `hwb()`, hex, or `rgb()` |
+| `rgb()` / `rgba()` strings with 0–1 decimal fractions | Convert `'rgb(0.5, 0.5, 0.5)'` to `'rgb(128, 128, 128)'` (or any supported string form) |
+| Numeric color values (e.g. `color: 42`) | Convert to a color string |
 
-### New color formats you can now use
-
-The new library accepts CSS Color 4 syntax that wasn't possible with
-tinycolor. All of these are now valid anywhere Plotly accepts a color
-string:
-
-```js
-'#ff0000aa'          // 8-digit hex with alpha
-'#f00a'              // 4-digit short hex with alpha
-'rgb(255 0 0)'       // space-separated rgb
-'rgba(255 0 0 / 0.5)' // slash-alpha rgba
-'hsl(0 100% 50% / 0.5)' // slash-alpha hsl
-'hsla(0, 100%, 50%, 0.5)' // hsla
-'hwb(0, 0%, 0%)'     // hwb (hue-whiteness-blackness)
-```
-
-See [test/image/mocks/color_syntax_formats.json](https://github.com/plotly/plotly.js/blob/master/test/image/mocks/color_syntax_formats.json)
-for a working example using each format.
-
-#### Browser compatibility
-
-All of these are parsed by Plotly in JavaScript and normalized to legacy
-`rgb(...)` / `rgba(...)` before being written to the DOM, so the browser
-never sees the modern syntax — your figures render the same in any
-browser that ran v3. The note below only matters if you also mirror these
-strings into your own stylesheets or template literals.
-
-Native CSS support:
-
-| Format | First supported |
-|---|---|
-| `#rrggbbaa`, `#rgba` | Chrome 62 (2017), Firefox 49 (2016), Safari 9.1 (2016) |
-| `rgb(r g b)`, `rgb(r g b / a)`, `hsl(h s l / a)` (space + slash-alpha) | Chrome 65 (2018), Firefox 52 (2017), Safari 12.1 (Mar 2019) |
-| `hsla()` | Universal since IE9 |
-| `hwb()` | Chrome 101 (Apr 2022), Firefox 96 (Jan 2022), Safari 15 (Sep 2021) |
-
-`hwb()` is the only format here that won't parse in browsers from ~2020
-or earlier. Everything else is safe in any browser shipped in the last
-seven years.
+Auto-computed contrast colors (heatmap text, `insidetextfont` on
+bars/waterfall, sankey hover on dark BG) may also shift by a few RGB units
+around mid-luminance backgrounds.
 
 ---
 
-## Chart Studio APIs removed
-
-*Implemented in [#7812](https://github.com/plotly/plotly.js/pull/7812).*
+## Removed Chart Studio APIs
 
-The legacy "Edit in Chart Studio" link, related config options, and the
-streaming token attribute have been removed. The `sendDataToCloud` modebar
-button and config option are retained — only the duplicate
-`editInChartStudio` button and the on-graph "Edit chart" link are gone.
+Config options removed from `Plotly.newPlot(gd, data, layout, config)`:
 
-### Removed config options
-
-`Plotly.newPlot(gd, data, layout, config)` no longer accepts:
+| Removed | Replacement |
+|---|---|
+| `showLink`, `linkText`, `sendData`, `showSources` | None — remove them |
+| `showEditInChartStudio` | `showSendToCloud` |
 
-| Removed | What it did | Replacement |
-|---|---|---|
-| `showLink` | Drew an "Edit chart" link at the bottom-right of the plot | None — remove the option |
-| `linkText` | Text for the `showLink` link | None — remove the option |
-| `sendData` | Whether the link uploaded data or just linked to a file | None — remove the option |
-| `showSources` | Hook that drew custom source links next to `showLink` | None — remove the option |
-| `showEditInChartStudio` | Pencil-icon variant of `sendDataToCloud` | Use `showSendToCloud` |
+The `editInChartStudio` modebar button is gone — switch to `sendDataToCloud`.
+The undocumented `stream: { token, maxpoints }` trace attribute is removed and
+now schema-rejected.
 
 ```js
 // Before
@@ -204,756 +92,127 @@ Plotly.newPlot(gd, data, layout, {
 });
 ```
 
-### Removed modebar button
-
-`editInChartStudio` is no longer a built-in modebar button. If you were
-adding it explicitly via `modeBarButtonsToAdd`, switch to `sendDataToCloud`:
-
-```js
-// Before
-{ modeBarButtonsToAdd: ['editInChartStudio'] }
-
-// After
-{ modeBarButtonsToAdd: ['sendDataToCloud'] }
-```
-
-### Removed trace attribute
-
-The undocumented `stream` attribute (`stream.token`, `stream.maxpoints`)
-has been removed from every trace type. It was a hook for the Chart
-Studio streaming service, which is no longer reachable. If you have
-figures containing `stream: { token: '...', maxpoints: N }` in their
-trace objects, delete those properties — they're now schema-rejected.
-
 ---
 
-## Mapbox traces and subplots removed
-
-*Implemented in [#7860](https://github.com/plotly/plotly.js/pull/7860).*
+## Removed mapbox traces and subplots
 
-The legacy mapbox-gl-js–based traces and subplot type have been removed.
-The MapLibre-based `map` family that has shadowed them since v2 is now
-the only map implementation.
-
-### Removed
+The legacy `mapbox`-based traces and subplot type are gone. Rename to the
+MapLibre-based `map` family. For deeper background on the switch, see [Mapbox
+to MapLibre migration](https://plotly.com/python/mapbox-to-maplibre/).
 
 | Removed | Replacement |
 |---|---|
-| `scattermapbox` trace | `scattermap` |
-| `choroplethmapbox` trace | `choroplethmap` |
-| `densitymapbox` trace | `densitymap` |
-| `layout.mapbox` subplot (and `mapbox2`, `mapbox3`, …) | `layout.map` (and `map2`, `map3`, …) |
-| `layout.mapbox.accesstoken` | None — MapLibre uses open tile providers |
-| `mapboxAccessToken` config option | None — see above |
+| `scattermapbox` | `scattermap` |
+| `choroplethmapbox` | `choroplethmap` |
+| `densitymapbox` | `densitymap` |
+| `layout.mapbox` (and `mapbox2`, `mapbox3`, …) | `layout.map` (and `map2`, `map3`, …) |
+| `layout.mapbox.accesstoken`, `config.mapboxAccessToken` | None — MapLibre uses open tile providers |
 | `plotly-mapbox.min.js` partial bundle | `plotly-map.min.js` |
 | Modebar buttons `zoomInMapbox`, `zoomOutMapbox`, `resetViewMapbox` | `zoomInMap`, `zoomOutMap`, `resetViewMap` |
-| `scrollZoom` flag value `'mapbox'` (e.g. `scrollZoom: 'mapbox+cartesian'`) | `'map'` |
+| `scrollZoom: 'mapbox'` (e.g. `'mapbox+cartesian'`) | `'map'` |
 
-The schema for `map` mirrors `mapbox` attribute-for-attribute (`domain`,
-`style`, `center`, `zoom`, `bearing`, `pitch`, `bounds`, `layers[...]`),
-so the migration is usually a rename.
+The attribute shape is unchanged — usually a straight rename works:
 
 ```js
 // Before
 {
     data: [{ type: 'scattermapbox', lon: [...], lat: [...] }],
-    layout: {
-        mapbox: {
-            style: 'open-street-map',
-            center: { lon: 0, lat: 0 },
-            zoom: 2,
-        },
-    },
+    layout: { mapbox: { style: 'open-street-map', center: {...}, zoom: 2 } },
     config: { mapboxAccessToken: 'pk.eyJ1...' },
 }
 
 // After
 {
     data: [{ type: 'scattermap', lon: [...], lat: [...] }],
-    layout: {
-        map: {
-            style: 'open-street-map',
-            center: { lon: 0, lat: 0 },
-            zoom: 2,
-        },
-    },
-    // mapboxAccessToken removed — MapLibre needs no token for the
-    // built-in styles
+    layout: { map: { style: 'open-street-map', center: {...}, zoom: 2 } },
+    // mapboxAccessToken removed
 }
 ```
 
-### Built-in style values
-
-Every built-in `style` name that worked on `mapbox` still works on `map`,
-but the tiles backing them differ — visual output **will change** even
-when no other figure changes:
-
-| Style name | Old (`mapbox`) | New (`map`) |
-|---|---|---|
-| `basic`, `streets`, `outdoors` | mapbox.com vector tiles (required token) | Carto Voyager |
-| `light` | mapbox.com light | Carto Positron |
-| `dark` | mapbox.com dark | Carto Dark Matter |
-| `satellite`, `satellite-streets` | mapbox.com satellite | ArcGIS World Imagery |
-| `white-bg`, `open-street-map` | unchanged | unchanged |
-| `carto-*`, `carto-*-nolabels` | n/a (already open) | unchanged |
-
-The three Stamen styles (`stamen-terrain`, `stamen-toner`,
-`stamen-watercolor`) are gone — Stamen tiles now require a Stadia API
-key. Users who need them can supply a custom `style` URL.
-
-### Custom style URLs
-
-Custom MapLibre / Mapbox-style JSON URLs continue to work. The
-`mapbox://styles/mapbox/...` short form is no longer resolved, since it
-requires authenticating to mapbox.com. Substitute the full URL of an
-equivalent open style, or self-host the style JSON.
-
-### Static export
-
-The Mapbox logo previously injected into static SVG / PNG exports of
-mapbox subplots is no longer drawn — MapLibre has no equivalent
-trademark requirement. Attribution provided by tile sources (Carto,
-OpenStreetMap, ArcGIS) is still rendered inside the map canvas.
+Built-in style names still work but use different tile providers (Carto,
+ArcGIS, OpenStreetMap) — visual output will shift. Stamen styles
+(`stamen-terrain`, `-toner`, `-watercolor`) are no longer built in — they now
+require a Stadia API key. The `mapbox://styles/mapbox/...` short-form URL is
+no longer resolved.
 
 ---
 
 ## Country name lookup
 
-*Implemented in [#7856](https://github.com/plotly/plotly.js/pull/7856).*
-
-`locationmode: 'country names'` on `choropleth` and `scattergeo` traces is
-now resolved by [country-iso-search](https://github.com/plotly/country-iso-search)
-instead of [country-regex](https://github.com/etpinard/country-regex). The
-attribute name, accepted values list, and ISO-3 output are unchanged —
-the difference is in *how* a name string is matched to an alpha-3 code.
-
-The old library walked a table of country-specific regular expressions
-and returned the first match. That made it lenient (substring matches
-worked) but ambiguity-prone — strings like `'Republic of'` could
-resolve to whichever entry's regex hit first. The new library does a
-sanitized exact lookup against a curated alias table, which is stricter
-about ambiguous input but accepts many more legitimate forms.
-
-### Names that resolved before but no longer do
-
-Strings that only matched because of overly broad regex fragments now
-fall back to the unrecognized-name log message and the location is
-skipped. In practice this hits inputs that weren't really country
-names — partial phrases, generic descriptors, or strings containing a
-country name as a substring of something else (e.g.
-`'Republic of Foo'`, `'Not Iran'`). If you were relying on a
-non-canonical form, switch to the country's name, an alias, or the
-ISO-3 / ISO-2 code.
-
-### Names and forms that now resolve
-
-The alias table is larger and the input is normalized before lookup,
-so a number of forms that previously failed now work:
-
-```js
-// All resolve to 'FRA'
-'France'
-'FR'                        // ISO 3166-1 alpha-2
-250                         // UN M49 numeric (number or string)
-'\u{1F1EB}\u{1F1F7}'        // flag emoji
-
-// Historical / native / punctuated names
-'Burma'                     // → 'MMR'
-'Türkiye'                   // → 'TUR' (diacritics stripped)
-'Cote d\'Ivoire'            // → 'CIV' (apostrophes ignored)
-'St. Kitts and Nevis'       // → 'KNA' ('St.' expands to 'Saint')
-'The Gambia'                // → 'GMB' (leading 'The ' dropped)
-```
-
-Matching is case-insensitive. Sanitization also collapses internal
-whitespace, drops `.` `()` `,`, maps `&` → `and`, and turns `-` / `–` /
-`—` into spaces — so cosmetic punctuation differences in your input
-data no longer block a match.
-
-### Disputed-territory codes are retained
-
-The user-assigned alpha-3 codes Plotly historically recognized for
-disputed regions still work:
-
-| Code | Region |
-|---|---|
-| `XAC` | Aksai Chin |
-| `XAP` | Arunachal Pradesh |
-| `XBT` | Bir Tawil |
-| `XHT` | Halaib Triangle |
-| `XJK` | Jammu and Kashmir |
-
-These are layered on top of the standard ISO 3166-1 records via
-[src/lib/custom_country_codes.ts](https://github.com/plotly/plotly.js/blob/master/src/lib/custom_country_codes.ts).
-Whether a feature for them appears on the rendered map still depends
-on the topojson resolution in use.
-
----
-
-## TypeScript types
-
-*Implemented in [#7680](https://github.com/plotly/plotly.js/pull/7680) and [#7868](https://github.com/plotly/plotly.js/pull/7868).*
-
-Plotly.js now ships its own TypeScript type definitions. `package.json`
-points `"types"` at `lib/index.d.ts`, so the types are picked up
-automatically — no separate `@types/*` install is needed.
-
-### Importing
-
-The package exports a default namespace, named exports, and a global
-`Plotly` namespace:
-
-```ts
-import Plotly from 'plotly.js';
-// or
-import * as Plotly from 'plotly.js';
-// or
-import { newPlot } from 'plotly.js';
-import type { Layout, Data, TraceType } from 'plotly.js';
-```
-
-A minimal typed example:
-
-```ts
-import { newPlot } from 'plotly.js';
-import type { Data, Layout } from 'plotly.js';
-
-const data: Data[] = [{ type: 'scatter', x: [1, 2, 3], y: [4, 5, 6] }];
-const layout: Partial<Layout> = { title: { text: 'Demo' } };
-
-await newPlot(div, data, layout);
-```
-
-### What's exported
-
-**Trace data** — `Data` (the union of every trace's typed data object),
-plus per-trace interfaces like `ScatterData`, `BarData`, `HeatmapData`,
-`ChoroplethData`, etc. Each per-trace interface narrows on `type`, so
-using `Data[]` in your figure lets TypeScript pick the right trace
-shape from the literal `type` value:
-
-```ts
-const data: Data[] = [
-    { type: 'bar', x: ['a', 'b'], y: [1, 2] },     // checked as BarData
-    { type: 'scatter', x: [1, 2], mode: 'lines' }, // checked as ScatterData
-];
-```
-
-Other exports:
-
-- **Layout** — `Layout` (the full layout interface), `LayoutAxis`,
-  `Legend`, `Annotation`, `Shape`, `Slider`, `UpdateMenu`, `Scene`, and
-  the rest of the component interfaces. Pass `Partial<Layout>` to
-  `newPlot` / `react` since most fields are optional.
-
-- **Config** — `Config`, `ToImgopts`, `ToImageButtonOptions`,
-  `DownloadImgopts`, `ModeBarDefaultButtons`, `ModeBarButton`, `Icon`.
-
-- **Trace/layout enums** — string-literal unions like `TraceType`,
-  `AxisType`, `Calendar`, `Dash`, `PatternShape`, `XRef`, `YRef`,
-  `MarkerSymbol`, `HoverInfo`, etc. Use these instead of bare `string`
-  to get narrowing on attribute values.
-
-- **Shared sub-interfaces** — `Font`, `ColorBar`, `HoverLabel`,
-  `Pattern`, `Domain`, `LegendGroupTitle`, `TickFormatStops`, etc.,
-  used wherever the schema reuses the same sub-attribute tree.
-
-- **Events** — `PlotMouseEvent`, `PlotHoverEvent`, `PlotSelectionEvent`,
-  `PlotRelayoutEvent`, `PlotRestyleEvent`, `LegendClickEvent`,
-  `SliderChangeEvent`, etc., plus `PlotlyEventName` for the union of
-  event names accepted by `on()` / `once()` / `removeListener()`.
-
-- **Animation & frames** — `AnimationOpts`, `Frame`, `Transition`,
-  `TransitionEasing`.
-
-- **Templates** — `Template` interface (and `TemplateFigure`,
-  `ValidateTemplateResult` from the template utilities).
-
-- **DOM** — `PlotlyHTMLElement` (the typed `Plotly.newPlot` graph
-  div), `Datum`, `TypedArray`, `Color`, `ColorScale`.
-
-### Notes on a few types
-
-**`Data` vs per-trace interfaces.** Prefer the `Data` union for figure
-literals (TypeScript discriminates on `type`); use the per-trace
-interface only when you have a value that is *guaranteed* to be one
-trace type — e.g. a helper that builds a `BarData` to push into a
-`Data[]`.
-
-**`Layout` is the input shape, not the resolved shape.** It mirrors
-what you pass to `newPlot`. The post-coerce internal shape used inside
-Plotly's own code (often called "FullLayout") is intentionally not
-exported. Likewise `Data` is the input shape; resolved trace state
-("FullData") is internal.
-
-**`PlotType` is an alias for `TraceType`.** Both name the same
-string-literal union of trace type names; existing code that imports
-`PlotType` keeps compiling. New code should prefer `TraceType`.
+`locationmode: 'country names'` on `choropleth` and `scattergeo` traces now
+uses a stricter matcher. Strings that only matched previously via broad regex
+fragments (e.g. `'Republic of'`, `'Not Iran'`) no longer resolve — locations
+are skipped. Switch to a canonical country name, an alias, or an ISO-3 / ISO-2
+code.
 
 ---
 
-## Scattermap icon defaults
-
-*Implemented in [#7825](https://github.com/plotly/plotly.js/pull/7825).*
-
-If you used `scattermap` or `scattermapbox` in v3, three rendering details
-have changed by the time you land on `scattermap` in v4:
-
-### Marker icons now respect `marker.color`
-
-`marker.color` on a scattermap trace is now applied to the icon by
-setting `icon-color` (plus a small `icon-halo` so the colored edges
-read cleanly). In v3 the property was set on the layer but the
-underlying icons weren't SDF sprites, so the color had no visible
-effect — coloring was effectively a no-op.
-
-In v4 the Maki icons are loaded with `{sdf: true}` and tinted with
-`marker.color`. Figures relying on the icon retaining its original
-artwork color will now render in the trace color. If you need the
-original tint, pick a Maki icon already in that color and set
-`marker.color: 'white'` (which becomes the identity tint for SDF
-sprites).
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 scattermap icons uncolored](/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v3.png) | ![v4 scattermap icons tinted red](/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v4.png) |
+## Auto-fitting on `map` and `geo` subplots
 
-### Maki icon set updated to v8 (via jsDelivr)
+Both subplot types now auto-fit their initial view to fit trace data.
 
-The icon CDN and version have changed:
+**For `map` subplots** (`scattermap`, `densitymap`): set `map.fitbounds:
+false`, or set `map.center` / `map.zoom` explicitly, to opt out.
 
-- **v3**: `https://unpkg.com/maki@2.1.0/icons/<name>.svg`
-- **v4**: `https://cdn.jsdelivr.net/npm/@mapbox/maki@8.2.0/icons/<name>.svg`
+**For `geo` subplots** (`scattergeo`, `choropleth`): `layout.geo.fitbounds`
+now defaults to `'locations'` (previously `false`). Set `fitbounds: false`, or
+set any view attribute (`center`, `projection.rotation`, `projection.scale`,
+`lonaxis.range`, `lataxis.range`), to opt out.
 
-A handful of icon names removed between Maki 2.1 and 8.2 will now
-silently fail to load (HTTP 404). If you were using one of the dropped
-icons, swap it for the nearest Maki 8 equivalent (see
-[Maki 8 icon list](https://labs.mapbox.com/maki-icons/)).
-
-### Legend swatch always renders as a circle
-
-`scattermap` legend swatches now always draw a circle, regardless of
-`marker.symbol`. In v3 the swatch went through the same code path as
-cartesian traces, which only understands the
-[Plotly-supported symbol names](https://github.com/plotly/plotly.js/blob/master/src/components/drawing/symbol_defs.js).
-On map traces, that produced inconsistent output: symbols with names
-that don't overlap the Plotly set (Maki-only names like `'airport'`,
-`'cafe'`) rendered as filled circles, while other symbols (`'square'`,
-`'star'`, etc.) rendered as broken/empty paths in the legend even
-though they draw correctly on the map. The v4 circle fallback makes
-the swatch consistent across every scattermap trace.
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 scattermap legend inconsistent](/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v3.png) | ![v4 scattermap legend all circles](/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v4.png) |
-
-If you were styling the legend swatch path directly based on
-`marker.symbol`, that selector will now always match a circle path on
-map traces.
-
----
-
-## Map subplots auto-frame to data
-
-*Implemented in [#7884](https://github.com/plotly/plotly.js/pull/7884).*
-
-`map` subplots now auto-frame the view to fit the trace data. In v3, the
-same layout produced a world view centered at `(0, 0)` with `zoom: 1`,
-requiring the user to supply `center` and `zoom` (or drag/scroll) to see
-their data.
-
-```js
-Plotly.newPlot(gd, [{
-    type: 'scattermap',
-    lon: [-122.4, -73.9, -87.6],
-    lat: [37.8, 40.7, 41.9]
-}], {
-    map: { style: 'basic' }
-});
-// v3: map opens centered at (0, 0) at zoom 1
-// v4: map opens framed on the three cities
-```
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 map with world view](/all_static/images/migrating-to-v4/migration_map_autofit_v3.png) | ![v4 map framed on cities](/all_static/images/migrating-to-v4/migration_map_autofit_v4.png) |
-
-Auto-framing runs on the initial render and again on data-only updates
-(`Plotly.restyle` of `lon`/`lat`, `Plotly.addTraces`, `Plotly.deleteTraces`)
-whenever the user hasn't overridden the view. Once the user pans, zooms,
-rotates, or tilts the map — or explicitly sets `center` / `zoom` / `bearing`
-/ `pitch` in the layout — auto-framing steps aside and preserves the
-chosen view across further data changes.
-
-### Opting out
-
-Two ways to disable auto-framing.
-
-**Set `map.fitbounds: false`** — recommended for intentional opt-out;
-explicit and independent of the view values.
+Figures that already supply view attributes render unchanged.
 
 ```js
+// Restore v3 world view for a map subplot
 { map: { fitbounds: false } }
-```
-
-**Set `map.center` or `map.zoom` explicitly** — any value counts as
-user intent, including `zoom: 0` and `center: { lon: 0, lat: 0 }`.
 
-```js
-// Keep the v3 world view:
-{ map: { center: { lon: 0, lat: 0 }, zoom: 1 } }
+// Restore v3 world view for a geo subplot
+{ geo: { fitbounds: false } }
 ```
 
-### Which traces contribute
-
-Each `map` subplot auto-frames independently, using only the
-`scattermap` and `densitymap` traces assigned to it (via the trace's
-`subplot` attribute). Each contributing trace's `lon` / `lat` arrays
-feed the frame, with non-finite entries skipped. Traces belonging to
-a different subplot (`map2`, `polar`, etc.) are framed by their own
-subplot, not this one; traces with `visible !== true` are ignored
-entirely.
-
-**`choroplethmap` traces skip auto-framing** because they carry
-`locations` / `geojson` rather than point lon/lat, so their extent
-can't be included without geojson bbox handling. When a visible
-`choroplethmap` sits on the subplot, the view falls back to the v3
-default. Set `map.center` and `map.zoom` explicitly to frame the choropleth.
-
-### Antimeridian data
-
-For data that straddles the antimeridian (points on both sides of ±180°),
-the auto-frame picks the compact crossing range rather than the
-long-way-around view. For example, `lon: [131.8855, -179]` frames as
-`[131.8855, 181]` (a ~49° span across the antimeridian) instead of the
-naive `[-179, 131.8855]` (~311° the wrong way).
-
-### `map.bounds` is unaffected
-
-The `map.bounds` layout attribute (which restricts panning) is a
-separate concern and continues to work as in v3. Auto-framing computes
-the *initial* view; `bounds` constrains *interactive* view movement.
-Both can coexist.
-
-### Relationship to `layout.geo.fitbounds`
-
-Both `map` and `geo` subplots now expose a `fitbounds` layout attribute,
-but the shapes differ:
-
-| | `map.fitbounds` | `geo.fitbounds` |
-|---|---|---|
-| Type | boolean | enumerated |
-| Values | `true` / `false` | `false` / `'locations'` / `'geojson'` |
-| Default | `true` | `'locations'` (was `false` in v3 — see [Geo subplots auto-frame by default](#geo-subplots-auto-frame-by-default)) |
-| Re-fits on data updates | yes, until user overrides view | yes, every render |
-
-If you use both subplot types in one figure, note that `map.fitbounds` is
-a straight on/off toggle, while `geo.fitbounds` also selects *what*
-contributes to the frame (visible `locations` only, vs. the entire trace
-`geojson`).
-
 ---
 
-## Geo subplots auto-frame by default
-
-*Implemented in [#7895](https://github.com/plotly/plotly.js/pull/7895).*
+## Scattermap rendering changes
 
-`layout.geo.fitbounds` now defaults to `'locations'` (v3 default: `false`).
-`geo` subplots — used by `scattergeo`, `choropleth`, and any other
-location-based geo trace — now auto-frame their initial view to fit the
-trace data, matching the behavior of `map` subplots. Figures that previously
-rendered the full world map (or the scope's default extent) now zoom to just
-the locations they plot.
-
-```js
-Plotly.newPlot(gd, [{
-    type: 'choropleth',
-    locations: ['CAN', 'MEX'],
-    z: [1, 2]
-}], {
-    // v3: full world map (fitbounds defaulted to false)
-    // v4: tight fit around Canada and Mexico (fitbounds now defaults to 'locations')
-});
-```
-
-| Before (v3) | After (v4) |
+| Change | Detail |
 |---|---|
-| ![v3 geo world view](/all_static/images/migrating-to-v4/migration_geo_autofit_v3.png) | ![v4 geo framed on Canada+Mexico](/all_static/images/migrating-to-v4/migration_geo_autofit_v4.png) |
-
-### How to opt out
-
-Two paths:
-
-**Explicit:** set `layout.geo.fitbounds: false` to restore the v3 default view.
-
-```js
-Plotly.newPlot(gd, [/* ... */], {
-    geo: { fitbounds: false }  // world view / scope-default view, as in v3
-});
-```
-
-**Implicit:** setting any of the view attributes that auto-fit would
-otherwise compute automatically disables auto-fit for that figure. Which
-attributes count depends on the projection:
-
-| Projection kind | Projection-specific opt-out attributes |
-|---|---|
-| Any non-`world` scope (checked first, even if the projection is also clipped) | `center.lon`, `center.lat`, `projection.scale` |
-| World scope + clipped projection (orthographic, azimuthal equal area, etc.) | `center.lon`, `center.lat`, `projection.scale`, `projection.rotation.lon`, `projection.rotation.lat` |
-| World scope, non-clipped projection (miller, robinson, mercator, etc.) | `center.lon`, `center.lat`, `projection.scale`, `projection.rotation.lon` |
-
-In addition to the projection-specific set above, setting either
-`lonaxis.range` or `lataxis.range` always disables auto-fit for that
-figure, regardless of projection type. Even for projections where
-fitbounds doesn't overwrite the ranges directly, the fitted
-`center`/`scale` would visually override whatever framing the ranges
-imply, so we treat setting a range as opt-out intent.
-
-Under the v4 default this means figures that supplied their own view
-attributes in v3 continue to render with those attributes — no code change
-needed. Auto-fit only kicks in when none of the relevant attributes are set.
-
-```js
-Plotly.newPlot(gd, [/* ... */], {
-    geo: {
-        projection: { rotation: { lon: -75 } }
-        // fitbounds is implicitly false because rotation.lon is set
-    }
-});
-```
-
-This differs from v3, where `fitbounds: 'locations'` would overwrite any
-user-supplied view attributes. In v4 the two are treated as opt-in to
-different framing modes: auto-fit or explicit view.
-
-### Projections that don't participate in auto-fit
-
-Three projection types skip auto-fit and render with the schema default
-view even when `fitbounds` is unset (i.e., defaulted to `'locations'`):
-
-- `'albers usa'` — a fixed composite projection with predetermined insets
-  for Alaska and Hawaii; it has no `center`/`rotation` concept for fitbounds
-  to target.
-- `'craig'` and `'satellite'` — the internal scale heuristic that drives
-  `fitbounds` compares data bounds against world bounds in the projected
-  plane, which is unreliable for these projections' non-linear (and,
-  for satellite, perspective-dependent) mapping. Auto-fit would zoom
-  incorrectly, so v4 skips it.
-
-For these projections `layout.geo.fitbounds` is silently forced to `false`
-in the resolved layout even if you leave it at the default. To fit
-locations under one of these projections, supply the view attributes
-yourself (`center`, `projection.rotation`, `projection.scale`, etc.).
-
-### Reset button behavior
-
-The modebar's Reset view button restores the auto-fit view when
-`fitbounds` is active, not the schema default. Prior to v4 there was no
-auto-fit default, so Reset simply restored the schema default; in v4 the
-initial view captured for reset is the fitted view.
+| Marker icons now respect `marker.color` | To keep icons in their original artwork color, set `marker.color: 'white'`. |
+| Maki icons load from `@mapbox/maki@8.2.0` via jsDelivr | A handful of icon names dropped between Maki 2.1 and 8.2 will 404 — swap to the nearest Maki 8 equivalent. |
+| Legend swatches always draw a circle | Regardless of `marker.symbol`. Selectors that styled the swatch path based on symbol name will now match a circle on map traces. |
 
 ---
 
-## Geo `fitbounds` framing for antimeridian features
-
-*Implemented in [#7891](https://github.com/plotly/plotly.js/pull/7891).*
-
-`layout.geo.fitbounds: 'locations'` (and `'geojson'`) now correctly frames
-choropleth and scattergeo location traces containing features that cross the
-±180° antimeridian — Russia, Fiji, Antarctica, New Zealand, and the Aleutian
-Islands portion of Alaska. In v3 these were mis-framed because the underlying
-bounding-box computation (`@turf/bbox`) reported a bogus whole-globe span
-(`[-180°, 180°]`) for any such feature, and the fit zoomed the map out to
-match. In v4, `computeBbox` uses `d3-geo.geoBounds`' widest-gap longitude
-algorithm on the feature's vertices and returns the compact crossing range
-(with `east > 180°` when the range wraps).
-
-Because v4 also flips the `fitbounds` default from `false` to `'locations'`
-(see [Geo subplots auto-frame by default](#geo-subplots-auto-frame-by-default)),
-figures that never set `fitbounds` explicitly now participate in auto-fit
-too — so this antimeridian fix reaches many more figures than it would
-have as a standalone change.
+## Shape legend `line.dash`
 
-### Which figures shift
-
-A figure sees a visible change when **both** of the following hold:
-
-- `layout.geo.fitbounds` is active — either explicitly set to `'locations'` /
-  `'geojson'`, or left at the v4 default (see the opt-out list in the
-  auto-fit-default section above), and
-- The figure contains a `choropleth` or `scattergeo` trace with `locations`
-  where at least one location resolves to a feature that crosses ±180°.
-
-Figures that opt out of auto-fit (`fitbounds: false`, an explicit view
-attribute, or one of the projections listed as skipping auto-fit), or that
-don't include an antimeridian-crossing feature, render identically to v3
-as far as this fix is concerned.
-
-### Example
-
-```js
-Plotly.newPlot(gd, [{
-    type: 'choropleth',
-    locations: ['RUS'],
-    z: [1],
-    colorscale: [[0, '#c33'], [1, '#c33']],
-    showscale: false
-}], {
-    geo: { fitbounds: 'locations', projection: { type: 'equirectangular' } },
-    width: 700,
-    height: 500
-});
-// v3: fits to a bogus [-180°, 180°] span — Russia is a small red strip at
-//     the top of the whole world.
-// v4: fits tightly to Russia's actual longitudinal extent (~19° through
-//     ~190°, unwrapped across the antimeridian).
-```
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 Russia mis-framed with empty space](/all_static/images/migrating-to-v4/migration_antimeridian_v3.png) | ![v4 Russia tightly framed](/all_static/images/migrating-to-v4/migration_antimeridian_v4.png) |
+Filled-shape legend markers (`type: 'rect'`, `'circle'`, or filled paths with
+`showlegend: true`) now draw their outline using the shape's `line.dash`
+value, matching the on-plot shape. No code change needed unless you had output
+locked to the v3 solid-outline behavior.
 
 ---
 
-## Geo subplot zoom limits
-
-*Implemented in [#7371](https://github.com/plotly/plotly.js/pull/7371).*
-
-Geo subplots accept two new attributes for clamping interactive zoom:
-
-| Attribute | Default | Effect |
-|---|---|---|
-| `layout.geo.projection.minscale` | `0` | Lower bound on zoom, expressed as a multiplier of `projection.scale`. `0` means no lower bound. |
-| `layout.geo.projection.maxscale` | `null` | Upper bound on zoom, expressed as a multiplier of `projection.scale`. `null` means no upper bound. |
-
-```js
-Plotly.newPlot(gd, [/* … */], {
-    geo: {
-        projection: {
-            scale: 1,
-            minscale: 0.5,   // can't zoom out past 50% of base
-            maxscale: 4,     // can't zoom in past 400% of base
-        },
-    },
-});
-```
-
-The defaults preserve v3 behavior — figures that don't set these
-attributes are unaffected.
-
-One init-time wrinkle: if `projection.scale` falls outside
-`[minscale, maxscale]`, Plotly now dispatches a synthetic zoom event on
-first plot to clamp it back into range. That emits a
-`plotly_relayout` event that v3 wouldn't have fired. If you have a
-listener that distinguishes user-driven zooms from programmatic ones,
-make sure it tolerates a single extra event at startup for figures
-whose initial `projection.scale` is outside the configured bounds.
-
----
-
-## Shape legend marker outlines honor `line.dash`
-
-*Implemented in [#7845](https://github.com/plotly/plotly.js/pull/7845).*
-
-Shapes rendered in the legend as filled markers (e.g. `type: 'rect'`,
-`'circle'`, or filled paths with `showlegend: true`) now draw the
-marker's outline using the shape's `line.dash` value. In v3 the marker
-outline was always solid regardless of the shape's dash style, so the
-swatch didn't match the shape on the plot. (Line-only shapes —
-`type: 'line'` — already drew their swatch dashed in v3; only the
-filled-marker path was hardcoded to solid.)
-
-```js
-Plotly.newPlot(gd, [], {
-    shapes: [{
-        type: 'rect',
-        x0: 0, x1: 1, y0: 0, y1: 1,
-        line: { dash: 'dot' },
-        fillcolor: 'rgba(200,0,0,0.2)',
-        showlegend: true,
-    }],
-});
-// v3: legend marker outline is solid
-// v4: legend marker outline is dotted, matching the on-plot shape
-```
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 shape legend outlines solid](/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v3.png) | ![v4 shape legend outlines dashed](/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v4.png) |
-
----
-
-## Overlaying axis `tickmode` defaults to `'sync'`
-
-*Implemented in [#7684](https://github.com/plotly/plotly.js/pull/7684).*
+## Overlaying axis `tickmode`
 
 An axis that overlays another axis (`layout.xaxis2.overlaying: 'x'`,
-`layout.yaxis2.overlaying: 'y'`, etc.) now defaults its `tickmode` to
-`'sync'` instead of `'auto'`. The overlay axis draws tick marks and
-gridlines at the same positions as its base axis, computing labels to
-match — rather than picking its own auto-fit tick positions.
-
-In v3 the two axes drew independent auto-tick grids, producing
-staggered gridlines that were hard to read and left no visual
-association between a gridline and a specific axis. Sync eliminates
-that overlap.
-
-```js
-Plotly.newPlot(gd, [
-    { y: [1, 3, 2], name: 'A' },
-    { y: [100, 300, 200], name: 'B', yaxis: 'y2' }
-], {
-    yaxis2: { overlaying: 'y', side: 'right' }
-    // v3: y2 picks its own ticks, producing a staggered grid
-    // v4: y2 places ticks at y's tick positions, with y2-range labels
-});
-```
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 staggered overlay ticks](/all_static/images/migrating-to-v4/migration_tickmode_v3.png) | ![v4 sync'd overlay ticks](/all_static/images/migrating-to-v4/migration_tickmode_v4.png) |
-
-### Exception: categorical / multicategory base axes
-
-When the overlaid (base) axis is `type: 'category'` or `'multicategory'`,
-`tickmode` continues to default to `'auto'` on the overlaying axis.
-Sync'ing tick positions to category slots is almost never the intent.
-
-### Opting out
-
-Set `tickmode: 'auto'` (or any other explicit value) on the overlaying
-axis to restore v3 behavior:
+`layout.yaxis2.overlaying: 'y'`, etc.) now defaults its `tickmode` to `'sync'`
+— the overlay draws its ticks at the base axis's positions with its own
+range's labels. Set `tickmode: 'auto'` on the overlay to restore v3's
+independent-grid behavior:
 
 ```js
 { yaxis2: { overlaying: 'y', side: 'right', tickmode: 'auto' } }
 ```
 
-### Incidental bugfix
-
-`showexponent`, `showtickprefix`, and `showticksuffix` values of
-`'first'` and `'last'` were previously ignored on axes rendered with
-`tickmode: 'sync'`. Any workaround for that (e.g., forcing `'all'` on
-overlay axes) is no longer needed in v4.
+Categorical / multicategory base axes are exempt — overlays over them keep
+defaulting to `'auto'`.
 
 ---
 
-## Sankey layout algorithm update
+## Sankey layout
 
-*Implemented in [#7830](https://github.com/plotly/plotly.js/pull/7830).*
+`@plotly/d3-sankey` was upgraded from 0.7.2 to 0.12.3. The schema is
+unchanged, but node y-positions and link paths shift for the same figure. No
+code change needed unless you had output locked to specific pixel positions.
 
-`@plotly/d3-sankey` has been upgraded from 0.7.2 to 0.12.3. The schema
-and API surface for `sankey` traces are unchanged — every attribute
-that worked in v3 still works in v4 — but the underlying layout
-algorithm was rewritten upstream across these versions, so node and
-link positions for the same figure shift.
-
-The most visible effect is that links tend to be straighter and cross
-each other less: the new relaxation step gives more weight to
-minimizing link travel between columns, so flows that previously
-swooped across the diagram now run closer to horizontal. Node
-y-positions within a column shift to accommodate this, and exact node
-heights / paddings can differ by a few pixels.
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 sankey with crossing links](/all_static/images/migrating-to-v4/migration_sankey_v3.png) | ![v4 sankey with rewritten layout](/all_static/images/migrating-to-v4/migration_sankey_v4.png) |
+To pin node/link order (for animation or side-by-side comparisons), use the
+new `sankey.node.sort` and `sankey.link.sort` attributes with `'input'`.
+Defaults preserve v3-equivalent auto ordering.

From 33b86d7c9f3a37fdff1280016fe10756a29f6050 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 22 Jul 2026 16:18:57 -0600
Subject: [PATCH 07/25] Add v4 'What's New' guide

---
 .../2026-07-20-whats-new-in-v4.md             | 965 ++++++++++++++++++
 1 file changed, 965 insertions(+)
 create mode 100644 _posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md

diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
new file mode 100644
index 000000000..89cdbfcda
--- /dev/null
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -0,0 +1,965 @@
+---
+description: Full details on new features and breaking changes in Plotly.js version 4.
+display_as: guide
+language: plotly_js
+layout: base
+name: What's New in Plotly.js v4
+order: 1
+page_type: u-guide
+permalink: javascript/guides/whats-new-in-v4/
+sitemap: false
+thumbnail: thumbnail/mixed.jpg
+---
+# What's New in Plotly.js v4
+
+This page is a comprehensive reference for the new features and breaking
+changes in Plotly.js v4. For a quick checklist of code changes to update
+existing charts, see [Migrating to Plotly.js
+v4](/javascript/guides/migrating-to-v4/).
+
+## Contents
+
+- [Minimum Node.js version](#minimum-nodejs-version)
+- [Color library swap (tinycolor2 → color)](#color-library-swap)
+- [Chart Studio APIs removed](#chart-studio-apis-removed)
+- [Mapbox traces and subplots removed](#mapbox-traces-and-subplots-removed)
+- [Country name lookup (country-regex → country-iso-search)](#country-name-lookup)
+- [TypeScript types](#typescript-types)
+- [Scattermap icon defaults](#scattermap-icon-defaults)
+- [Map subplots auto-fit to data](#map-subplots-auto-fit-to-data)
+- [Geo subplots auto-fit by default](#geo-subplots-auto-fit-by-default)
+- [Geo `fitbounds` framing for antimeridian features](#geo-fitbounds-framing-for-antimeridian-features)
+- [Geo subplot zoom limits](#geo-subplot-zoom-limits)
+- [Shape legend marker outlines honor `line.dash`](#shape-legend-marker-outlines-honor-line-dash)
+- [Overlaying axis `tickmode` defaults to `'sync'`](#overlaying-axis-tickmode-defaults-to-sync)
+- [Sankey layout algorithm update](#sankey-layout-algorithm-update)
+- [Sankey node and link ordering](#sankey-node-and-link-ordering)
+
+---
+
+## Minimum Node.js version
+
+*Implemented in [#7861](https://github.com/plotly/plotly.js/pull/7861).*
+
+Plotly.js now requires Node.js v22 or newer. The previous floor was v18, which
+has reached end-of-life.
+
+This only affects you if:
+
+| Scenario | Why |
+|---|---|
+| You build Plotly.js from source | Contributors and custom bundles |
+| You run Plotly.js in a Node.js runtime | Server-side rendering via jsdom, validation scripts, image export pipelines, etc. |
+| You install via `yarn` or `pnpm` | Both enforce `engines` strictly (`npm` prints a warning but installs) |
+
+Consumers who only load the pre-built browser bundle (`plotly.min.js` or a
+partial bundle like `plotly-basic.min.js`) are unaffected — the bundle runs in
+browsers, not Node.
+
+If you're on Node 18 or 20, upgrade to 22 LTS. `npm` will print a warning on
+install but won't fail; `yarn` and `pnpm` will refuse to install unless your
+environment satisfies `engines.node >= 22.0.0`.
+
+---
+
+## Color library swap
+
+*Implemented in [#7536](https://github.com/plotly/plotly.js/pull/7536).*
+
+In v4, Plotly's internal color processing was switched from
+[tinycolor2](https://github.com/bgrins/TinyColor) to
+[color](https://github.com/Qix-/color). The new library is actively maintained
+and supports modern CSS Color 4 syntax, but a handful of behaviors changed in
+the process.
+
+### Color string inputs that no longer work
+
+**`hsv()` color strings are no longer accepted.**
+
+```js
+// Before
+{ marker: { color: 'hsv(200, 80%, 80%)' } }
+
+// After — convert to hsl, hwb, hex, or rgb
+{ marker: { color: 'hsl(200, 67%, 47%)' } }
+```
+
+A color in the unsupported format will fall back to the attribute's default.
+
+**`rgb()` / `rgba()` strings with 0–1 decimal fractions are no longer
+accepted.**
+
+```js
+// Before — tinycolor parsed this as 0–1 fractions
+'rgb(0.5, 0.5, 0.5)'  // → rgb(128, 128, 128)
+
+// After — the underlying library reads them as integer 0–255 (truncated)
+'rgb(0.5, 0.5, 0.5)'  // → rgb(1, 1, 1)
+```
+
+Convert any inputs of the form `rgb(0.5, 0.5, 0.5)` to `rgb(128, 128, 128)`
+(or any other supported color string) before passing them to Plotly.
+
+Mixed-format strings where at least one component is `>= 1` (e.g. `rgb(255,
+0.0, 0.0)`) continue to render correctly: the new parser treats the `0.0`
+components as integer `0`.
+
+**Numeric color inputs are now rejected.**
+
+```js
+// Before — silently accepted, rendered as near-black
+{ marker: { color: 42 } }
+
+// After — falls back to the attribute default
+```
+
+If you were relying on numeric color values being coerced, convert them to
+color strings before passing them to Plotly.
+
+### Color computation output changes
+
+A handful of Plotly's derived colors shift by a few RGB units. Visible places
+where output shifts:
+
+| Where | Example |
+|---|---|
+| Heatmap auto-contrast text | Cells in the mid-luminance range flip between dark grey and white on colorscales like Viridis or Jet |
+| Auto-generated `insidetextfont` color on bars/waterfall | Same threshold shift around mid-luminance backgrounds |
+| Sankey default hover color (dark BG) | RGB channels shift by 1 unit per channel vs v3 |
+
+Example — the four cells with `z` values 55, 56, and 60 (both occurrences)
+shift their text from white in v3 to dark grey in v4 on a Viridis heatmap,
+because the underlying color library computes cell luminance with a slightly
+different formula.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 Viridis heatmap with white text on mid-luminance cells](/all_static/images/whats-new-in-v4/migration_color_heatmap_v3.png) | ![v4 Viridis heatmap with dark text on those cells](/all_static/images/whats-new-in-v4/migration_color_heatmap_v4.png) |
+
+### New color formats you can now use
+
+The new library accepts CSS Color 4 syntax that wasn't possible with
+tinycolor. All of these are now valid anywhere Plotly accepts a color string:
+
+```js
+'#ff0000aa'          // 8-digit hex with alpha
+'#f00a'              // 4-digit short hex with alpha
+'rgb(255 0 0)'       // space-separated rgb
+'rgba(255 0 0 / 0.5)' // slash-alpha rgba
+'hsl(0 100% 50% / 0.5)' // slash-alpha hsl
+'hsla(0, 100%, 50%, 0.5)' // hsla
+'hwb(0, 0%, 0%)'     // hwb (hue-whiteness-blackness)
+```
+
+See
+[test/image/mocks/color_syntax_formats.json](https://github.com/plotly/plotly.js/blob/master/test/image/mocks/color_syntax_formats.json)
+for a working example using each format.
+
+#### Browser compatibility
+
+All of these are parsed by Plotly in JavaScript and normalized to legacy
+`rgb(...)` / `rgba(...)` before being written to the DOM, so the browser never
+sees the modern syntax — your figures render the same in any browser that ran
+v3. The note below only matters if you also mirror these strings into your own
+stylesheets or template literals.
+
+Native CSS support:
+
+| Format | First supported |
+|---|---|
+| `#rrggbbaa`, `#rgba` | Chrome 62 (2017), Firefox 49 (2016), Safari 9.1 (2016) |
+| `rgb(r g b)`, `rgb(r g b / a)`, `hsl(h s l / a)` (space + slash-alpha) | Chrome 65 (2018), Firefox 52 (2017), Safari 12.1 (Mar 2019) |
+| `hsla()` | Universal since IE9 |
+| `hwb()` | Chrome 101 (Apr 2022), Firefox 96 (Jan 2022), Safari 15 (Sep 2021) |
+
+`hwb()` is the only format here that won't parse in browsers from ~2020 or
+earlier. Everything else is safe in any browser shipped in the last seven
+years.
+
+---
+
+## Chart Studio APIs removed
+
+*Implemented in [#7812](https://github.com/plotly/plotly.js/pull/7812).*
+
+The legacy "Edit in Chart Studio" link, related config options, and the
+streaming token attribute have been removed. The `sendDataToCloud` modebar
+button and config option are retained — only the duplicate `editInChartStudio`
+button and the on-graph "Edit chart" link are gone.
+
+### Removed config options
+
+`Plotly.newPlot(gd, data, layout, config)` no longer accepts:
+
+| Removed | What it did | Replacement |
+|---|---|---|
+| `showLink` | Drew an "Edit chart" link at the bottom-right of the plot | None — remove the option |
+| `linkText` | Text for the `showLink` link | None — remove the option |
+| `sendData` | Whether the link uploaded data or just linked to a file | None — remove the option |
+| `showSources` | Hook that drew custom source links next to `showLink` | None — remove the option |
+| `showEditInChartStudio` | Pencil-icon variant of `sendDataToCloud` | Use `showSendToCloud` |
+
+```js
+// Before
+Plotly.newPlot(gd, data, layout, {
+    showLink: true,
+    linkText: 'View on Plotly',
+    showEditInChartStudio: true,
+});
+
+// After
+Plotly.newPlot(gd, data, layout, {
+    showSendToCloud: true,
+});
+```
+
+### Removed modebar button
+
+`editInChartStudio` is no longer a built-in modebar button. If you were adding
+it explicitly via `modeBarButtonsToAdd`, switch to `sendDataToCloud`:
+
+```js
+// Before
+{ modeBarButtonsToAdd: ['editInChartStudio'] }
+
+// After
+{ modeBarButtonsToAdd: ['sendDataToCloud'] }
+```
+
+### Removed trace attribute
+
+The undocumented `stream` attribute (`stream.token`, `stream.maxpoints`) has
+been removed from every trace type. It was a hook for the Chart Studio
+streaming service, which is no longer reachable. If you have figures
+containing `stream: { token: '...', maxpoints: N }` in their trace objects,
+delete those properties — they're now schema-rejected.
+
+---
+
+## Mapbox traces and subplots removed
+
+*Implemented in [#7860](https://github.com/plotly/plotly.js/pull/7860).*
+
+The legacy mapbox-gl-js–based traces and subplot type have been removed. The
+MapLibre-based `map` family that has shadowed them since v2 is now the only
+map implementation. For deeper background on the switch, see [Mapbox to
+MapLibre migration](https://plotly.com/python/mapbox-to-maplibre/).
+
+### Removed
+
+| Removed | Replacement |
+|---|---|
+| `scattermapbox` trace | `scattermap` |
+| `choroplethmapbox` trace | `choroplethmap` |
+| `densitymapbox` trace | `densitymap` |
+| `layout.mapbox` subplot (and `mapbox2`, `mapbox3`, …) | `layout.map` (and `map2`, `map3`, …) |
+| `layout.mapbox.accesstoken` | None — MapLibre uses open tile providers |
+| `mapboxAccessToken` config option | None — see above |
+| `plotly-mapbox.min.js` partial bundle | `plotly-map.min.js` |
+| Modebar buttons `zoomInMapbox`, `zoomOutMapbox`, `resetViewMapbox` | `zoomInMap`, `zoomOutMap`, `resetViewMap` |
+| `scrollZoom` flag value `'mapbox'` (e.g. `scrollZoom: 'mapbox+cartesian'`) | `'map'` |
+
+The schema for `map` mirrors `mapbox` attribute-for-attribute (`domain`,
+`style`, `center`, `zoom`, `bearing`, `pitch`, `bounds`, `layers[...]`), so
+the migration is usually a rename.
+
+```js
+// Before
+{
+    data: [{ type: 'scattermapbox', lon: [...], lat: [...] }],
+    layout: {
+        mapbox: {
+            style: 'open-street-map',
+            center: { lon: 0, lat: 0 },
+            zoom: 2,
+        },
+    },
+    config: { mapboxAccessToken: 'pk.eyJ1...' },
+}
+
+// After
+{
+    data: [{ type: 'scattermap', lon: [...], lat: [...] }],
+    layout: {
+        map: {
+            style: 'open-street-map',
+            center: { lon: 0, lat: 0 },
+            zoom: 2,
+        },
+    },
+    // mapboxAccessToken removed — MapLibre needs no token for the
+    // built-in styles
+}
+```
+
+### Built-in style values
+
+Every built-in `style` name that worked on `mapbox` still works on `map`, but
+the tiles backing them differ — visual output **will change** even when no
+other figure changes:
+
+| Style name | Old (`mapbox`) | New (`map`) |
+|---|---|---|
+| `basic`, `streets`, `outdoors` | mapbox.com vector tiles (required token) | Carto Voyager |
+| `light` | mapbox.com light | Carto Positron |
+| `dark` | mapbox.com dark | Carto Dark Matter |
+| `satellite`, `satellite-streets` | mapbox.com satellite | ArcGIS World Imagery |
+| `white-bg`, `open-street-map` | unchanged | unchanged |
+| `carto-*`, `carto-*-nolabels` | n/a (already open) | unchanged |
+
+The three Stamen styles (`stamen-terrain`, `stamen-toner`,
+`stamen-watercolor`) are gone — Stamen tiles now require a Stadia API key.
+Users who need them can supply a custom `style` URL.
+
+### Custom style URLs
+
+Custom MapLibre / Mapbox-style JSON URLs continue to work. The
+`mapbox://styles/mapbox/...` short form is no longer resolved, since it
+requires authenticating to mapbox.com. Substitute the full URL of an
+equivalent open style, or self-host the style JSON.
+
+---
+
+## Country name lookup
+
+*Implemented in [#7856](https://github.com/plotly/plotly.js/pull/7856).*
+
+`locationmode: 'country names'` on `choropleth` and `scattergeo` traces is now
+resolved by [country-iso-search](https://github.com/plotly/country-iso-search)
+instead of [country-regex](https://github.com/etpinard/country-regex). The
+attribute name, accepted values list, and ISO-3 output are unchanged — the
+difference is in *how* a name string is matched to an alpha-3 code.
+
+The old library walked a table of country-specific regular expressions and
+returned the first match. That made it lenient (substring matches worked) but
+ambiguity-prone — strings like `'Republic of'` could resolve to whichever
+entry's regex hit first. The new library does a sanitized exact lookup against
+a curated alias table, which is stricter about ambiguous input but accepts
+many more legitimate forms.
+
+### Previously recognized names that no longer work
+
+Strings that only matched because of overly broad regex fragments now fall
+back to the unrecognized-name log message and the location is skipped. In
+practice this hits inputs that weren't really country names — partial phrases,
+generic descriptors, or strings containing a country name as a substring of
+something else (e.g. `'Republic of Foo'`, `'Not Iran'`). If you were relying
+on a non-canonical form, switch to the country's name, an alias, or the ISO-3
+/ ISO-2 code.
+
+### Names and forms that now resolve
+
+The alias table is larger and the input is normalized before lookup, so a
+number of forms that previously failed now work:
+
+```js
+// All resolve to 'FRA'
+'France'
+'FR'                        // ISO 3166-1 alpha-2
+250                         // UN M49 numeric (number or string)
+'\u{1F1EB}\u{1F1F7}'        // flag emoji
+
+// Historical / native / punctuated names
+'Burma'                     // → 'MMR'
+'Türkiye'                   // → 'TUR' (diacritics stripped)
+'Cote d\'Ivoire'            // → 'CIV' (apostrophes ignored)
+'St. Kitts and Nevis'       // → 'KNA' ('St.' expands to 'Saint')
+'The Gambia'                // → 'GMB' (leading 'The ' dropped)
+```
+
+Matching is case-insensitive. Sanitization also collapses internal whitespace,
+drops `.` `()` `,`, maps `&` → `and`, and turns `-` / `–` / `—` into spaces —
+so cosmetic punctuation differences in your input data no longer block a
+match.
+
+### Disputed-territory codes are retained
+
+The user-assigned alpha-3 codes Plotly historically recognized for disputed
+regions still work:
+
+| Code | Region |
+|---|---|
+| `XAC` | Aksai Chin |
+| `XAP` | Arunachal Pradesh |
+| `XBT` | Bir Tawil |
+| `XHT` | Halaib Triangle |
+| `XJK` | Jammu and Kashmir |
+
+These are layered on top of the standard ISO 3166-1 records via
+[src/lib/custom_country_codes.ts](https://github.com/plotly/plotly.js/blob/master/src/lib/custom_country_codes.ts).
+Whether a feature for them appears on the rendered map still depends on the
+topojson resolution in use.
+
+---
+
+## TypeScript types
+
+*Implemented in [#7680](https://github.com/plotly/plotly.js/pull/7680) and
+[#7868](https://github.com/plotly/plotly.js/pull/7868).*
+
+Plotly.js now ships its own TypeScript type definitions. `package.json` points
+`"types"` at `lib/index.d.ts`, so the types are picked up automatically — no
+separate `@types/*` install is needed.
+
+### Importing
+
+The package exports a default namespace, named exports, and a global `Plotly`
+namespace:
+
+```ts
+import Plotly from 'plotly.js';
+// or
+import * as Plotly from 'plotly.js';
+// or
+import { newPlot } from 'plotly.js';
+import type { Layout, Data, TraceType } from 'plotly.js';
+```
+
+A minimal typed example:
+
+```ts
+import { newPlot } from 'plotly.js';
+import type { Data, Layout } from 'plotly.js';
+
+const data: Data[] = [{ type: 'scatter', x: [1, 2, 3], y: [4, 5, 6] }];
+const layout: Partial<Layout> = { title: { text: 'Demo' } };
+
+await newPlot(div, data, layout);
+```
+
+### What's exported
+
+**Trace data** — `Data` (the union of every trace's typed data object), plus
+per-trace interfaces like `ScatterData`, `BarData`, `HeatmapData`,
+`ChoroplethData`, etc. Each per-trace interface narrows on `type`, so using
+`Data[]` in your figure lets TypeScript pick the right trace shape from the
+literal `type` value:
+
+```ts
+const data: Data[] = [
+    { type: 'bar', x: ['a', 'b'], y: [1, 2] },     // checked as BarData
+    { type: 'scatter', x: [1, 2], mode: 'lines' }, // checked as ScatterData
+];
+```
+
+Other exports:
+
+| Category | Exports |
+|---|---|
+| Layout | `Layout` (the full layout interface), `LayoutAxis`, `Legend`, `Annotation`, `Shape`, `Slider`, `UpdateMenu`, `Scene`, and the rest of the component interfaces. Pass `Partial<Layout>` to `newPlot` / `react` since most fields are optional. |
+| Config | `Config`, `ToImgopts`, `ToImageButtonOptions`, `DownloadImgopts`, `ModeBarDefaultButtons`, `ModeBarButton`, `Icon`. |
+| Trace/layout enums | String-literal unions like `TraceType`, `AxisType`, `Calendar`, `Dash`, `PatternShape`, `XRef`, `YRef`, `MarkerSymbol`, `HoverInfo`, etc. Use these instead of bare `string` to get narrowing on attribute values. |
+| Shared sub-interfaces | `Font`, `ColorBar`, `HoverLabel`, `Pattern`, `Domain`, `LegendGroupTitle`, `TickFormatStops`, etc. — used wherever the schema reuses the same sub-attribute tree. |
+| Events | `PlotMouseEvent`, `PlotHoverEvent`, `PlotSelectionEvent`, `PlotRelayoutEvent`, `PlotRestyleEvent`, `LegendClickEvent`, `SliderChangeEvent`, etc., plus `PlotlyEventName` for the union of event names accepted by `on()` / `once()` / `removeListener()`. |
+| Animation & frames | `AnimationOpts`, `Frame`, `Transition`, `TransitionEasing`. |
+| Templates | `Template` interface (and `TemplateFigure`, `ValidateTemplateResult` from the template utilities). |
+| DOM | `PlotlyHTMLElement` (the typed `Plotly.newPlot` graph div), `Datum`, `TypedArray`, `Color`, `ColorScale`. |
+
+### Notes on a few types
+
+**`Data` vs per-trace interfaces.** Prefer the `Data` union for figure
+literals (TypeScript discriminates on `type`); use the per-trace interface
+only when you have a value that is *guaranteed* to be one trace type — e.g. a
+helper that builds a `BarData` to push into a `Data[]`.
+
+**`Layout` is the input shape, not the resolved shape.** It mirrors what you
+pass to `newPlot`. The post-coerce internal shape used inside Plotly's own
+code (often called "FullLayout") is intentionally not exported. Likewise
+`Data` is the input shape; resolved trace state ("FullData") is internal.
+
+**`PlotType` is an alias for `TraceType`.** Both name the same string-literal
+union of trace type names; existing code that imports `PlotType` keeps
+compiling. New code should prefer `TraceType`.
+
+---
+
+## Scattermap icon defaults
+
+*Implemented in [#7825](https://github.com/plotly/plotly.js/pull/7825).*
+
+If you used `scattermap` or `scattermapbox` in v3, three rendering details
+have changed by the time you land on `scattermap` in v4:
+
+### Marker icons now respect `marker.color`
+
+`marker.color` on a scattermap trace is now applied to the icon by setting
+`icon-color`.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 scattermap icons uncolored](/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v3.png) | ![v4 scattermap icons tinted red](/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v4.png) |
+
+### Maki icon set updated to v8 (via jsDelivr)
+
+The icon CDN and version have changed:
+
+| Version | URL |
+|---|---|
+| v3 | `https://unpkg.com/maki@2.1.0/icons/<name>.svg` |
+| v4 | `https://cdn.jsdelivr.net/npm/@mapbox/maki@8.2.0/icons/<name>.svg` |
+
+A handful of icon names removed between Maki 2.1 and 8.2 will now silently
+fail to load (HTTP 404). If you were using one of the dropped icons, swap it
+for the nearest Maki 8 equivalent (see [Maki 8 icon
+list](https://labs.mapbox.com/maki-icons/)).
+
+### Legend swatch always renders as a circle
+
+`scattermap` legend swatches now always draw a circle, regardless of
+`marker.symbol`. In v3 the swatch went through the same code path as cartesian
+traces, which only understands the [Plotly-supported symbol
+names](https://github.com/plotly/plotly.js/blob/master/src/components/drawing/symbol_defs.js).
+On map traces, that produced inconsistent output: symbols with names that
+don't overlap the Plotly set (Maki-only names like `'airport'`, `'cafe'`)
+rendered as filled circles, while other symbols (`'square'`, `'star'`, etc.)
+rendered as broken/empty paths in the legend even though they draw correctly
+on the map. The v4 circle fallback makes the swatch consistent across every
+scattermap trace.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 scattermap legend inconsistent](/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v3.png) | ![v4 scattermap legend all circles](/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v4.png) |
+
+If you were styling the legend swatch path directly based on `marker.symbol`,
+that selector will now always match a circle path on map traces.
+
+---
+
+## Map subplots auto-fit to data
+
+*Implemented in [#7884](https://github.com/plotly/plotly.js/pull/7884).*
+
+`map` subplots now auto-fit the view to fit the trace data. In v3, the same
+layout produced a world view centered at `(0, 0)` with `zoom: 1`, requiring
+the user to supply `center` and `zoom` (or drag/scroll) to see their data.
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'scattermap',
+    lon: [-122.4, -73.9, -87.6],
+    lat: [37.8, 40.7, 41.9]
+}], {
+    map: { style: 'basic' }
+});
+// v3: map opens centered at (0, 0) at zoom 1
+// v4: map opens framed on the three cities
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 map with world view](/all_static/images/whats-new-in-v4/migration_map_autofit_v3.png) | ![v4 map framed on cities](/all_static/images/whats-new-in-v4/migration_map_autofit_v4.png) |
+
+Auto-fitting runs on the initial render and again on data-only updates
+(`Plotly.restyle` of `lon`/`lat`, `Plotly.addTraces`, `Plotly.deleteTraces`)
+whenever the user hasn't overridden the view. Once the user pans, zooms,
+rotates, or tilts the map — or explicitly sets `center` / `zoom` / `bearing` /
+`pitch` in the layout — auto-fitting steps aside and preserves the chosen view
+across further data changes.
+
+### Disabling auto-fitting
+
+There are two ways to disable auto-fitting:
+
+**Set `map.fitbounds: false`** — disables automatic auto-fitting and instead
+defaults to showing a map with center `(0, 0)` and zoom `1`, as in v3.
+
+```js
+{ map: { fitbounds: false } }
+```
+
+**Set `map.center` or `map.zoom` explicitly** — passing any value for
+`map.zoom` or `map.center` (including the defaults of `zoom: 1` or `center: {
+lon: 0, lat: 0 }`) is taken as a signal to follow the user provided values
+rather than choosing zoom and center via auto-fitting.
+
+```js
+// Keep the v3 world view:
+{ map: { center: { lon: 0, lat: 0 }, zoom: 1 } }
+```
+
+### Which traces contribute
+
+`scattermap` and `densitymap` traces are affected by this change.
+**`choroplethmap` traces skip auto-fitting** because their data contains
+geographic regions, whose bounding boxes must be computed differently. When a
+subplot contains a `choroplethmap` trace, auto-fitting is disabled and the
+defaults (`zoom: 1` and `center: { lon: 0, lat: 0 }`) are used.
+
+### Data that crosses the antimeridian
+
+For data that straddles the antimeridian (points on both sides of ±180°, in
+the middle of the Pacific Ocean), the auto-fit picks the compact crossing
+range rather than the long-way-around view. For example, `lon: [131.8855,
+-179]` frames as `[131.8855, 181]` (a ~49° span across the antimeridian)
+instead of the naive `[-179, 131.8855]` (~311° the wrong way).
+
+### `map.bounds` is unaffected
+
+The `map.bounds` layout attribute (which restricts panning) is a separate
+concern and continues to work as in v3. Auto-fitting computes the *initial*
+view; `bounds` constrains *interactive* view movement. Both can coexist.
+
+### Relationship to `layout.geo.fitbounds`
+
+Both `map` and `geo` subplots now expose a `fitbounds` layout attribute, but
+the shapes differ:
+
+| | `map.fitbounds` | `geo.fitbounds` |
+|---|---|---|
+| Type | enumerated | enumerated |
+| Values | `false` / `'locations'` | `false` / `'locations'` / `'geojson'` |
+| Default | `'locations'` | `'locations'` (was `false` in v3 — see [Geo subplots auto-fit by default](#geo-subplots-auto-fit-by-default)) |
+| Re-fits on data updates | yes, until user overrides view | yes, every render |
+
+Both accept `false` (disable auto-fit) and `'locations'` (fit to trace lon/lat
+data); `geo.fitbounds` additionally accepts `'geojson'` to frame the entire
+geojson feature set rather than just visible locations.
+
+---
+
+## Geo subplots auto-fit by default
+
+*Implemented in [#7895](https://github.com/plotly/plotly.js/pull/7895).*
+
+`layout.geo.fitbounds` now defaults to `'locations'` (v3 default: `false`).
+`geo` subplots — used by `scattergeo`, `choropleth`, and any other
+location-based geo trace — now auto-fit their initial view to fit the trace
+data, matching the behavior of `map` subplots. Figures that previously
+rendered the full world map (or the scope's default extent) now zoom to just
+the locations they plot.
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'choropleth',
+    locations: ['CAN', 'MEX'],
+    z: [1, 2]
+}], {
+    // v3: full world map (fitbounds defaulted to false)
+    // v4: tight fit around Canada and Mexico (fitbounds now defaults to 'locations')
+});
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 geo world view](/all_static/images/whats-new-in-v4/migration_geo_autofit_v3.png) | ![v4 geo framed on Canada+Mexico](/all_static/images/whats-new-in-v4/migration_geo_autofit_v4.png) |
+
+### Disabling auto-fitting
+
+There are two ways to disable auto-fitting:
+
+**Set `layout.geo.fitbounds: false`** — disables automatic auto-fitting and
+instead defaults to showing a map with center `(0, 0)` and scale `1`, as in
+v3.
+
+```js
+Plotly.newPlot(gd, [/* ... */], {
+    geo: { fitbounds: false }  // world view / scope-default view, as in v3
+});
+```
+
+**Implicit:** setting `layout.center` or specific attributes under
+`layout.projection` will disable auto-fit for that figure. Which attributes
+count depends on the projection:
+
+| Projection kind | Projection-specific opt-out attributes |
+|---|---|
+| Any non-`world` scope (checked first, even if the projection is also clipped) | `center.lon`, `center.lat`, `projection.scale` |
+| World scope + clipped projection (orthographic, azimuthal equal area, etc.) | `center.lon`, `center.lat`, `projection.scale`, `projection.rotation.lon`, `projection.rotation.lat` |
+| World scope, non-clipped projection (miller, robinson, mercator, etc.) | `center.lon`, `center.lat`, `projection.scale`, `projection.rotation.lon` |
+
+In addition to the projection-specific set above, setting either
+`lonaxis.range` or `lataxis.range` always disables auto-fit for that figure,
+regardless of projection type. Even for projections where fitbounds doesn't
+overwrite the ranges directly, the fitted `center`/`scale` would visually
+override whatever framing the ranges imply, so we treat setting a range as
+opt-out intent.
+
+Under the v4 default this means figures that supplied their own view
+attributes in v3 continue to render with those attributes — no code change
+needed. Auto-fit only kicks in when none of the relevant attributes are set.
+
+```js
+Plotly.newPlot(gd, [/* ... */], {
+    geo: {
+        projection: { rotation: { lon: -75 } }
+        // fitbounds is implicitly false because rotation.lon is set
+    }
+});
+```
+
+This differs from v3, where `fitbounds: 'locations'` would overwrite any
+user-supplied view attributes. In v4 the two are treated as opt-in to
+different framing modes: auto-fit or explicit view.
+
+### Projections that don't participate in auto-fit
+
+Three projection types skip auto-fit and render with the schema default view
+even when `fitbounds` is unset (i.e., defaulted to `'locations'`):
+
+| Projection | Why it skips auto-fit |
+|---|---|
+| `'albers usa'` | A fixed composite projection with predetermined insets for Alaska and Hawaii; it has no `center` / `rotation` concept for fitbounds to target. |
+| `'craig'` and `'satellite'` | The internal scale heuristic that drives `fitbounds` compares data bounds against world bounds in the projected plane, which is unreliable for these projections' non-linear (and, for satellite, perspective-dependent) mapping. Auto-fit would zoom incorrectly, so v4 skips it. |
+
+For these projections `layout.geo.fitbounds` is silently forced to `false` in
+the resolved layout even if you leave it at the default. To fit locations
+under one of these projections, supply the view attributes yourself (`center`,
+`projection.rotation`, `projection.scale`, etc.).
+
+### Reset button behavior
+
+The modebar's Reset view button restores the auto-fit view when `fitbounds` is
+active, not the schema default. Prior to v4 there was no auto-fit default, so
+Reset simply restored the schema default; in v4 the initial view captured for
+reset is the fitted view.
+
+---
+
+## Geo `fitbounds` framing for antimeridian features
+
+*Implemented in [#7891](https://github.com/plotly/plotly.js/pull/7891).*
+
+`layout.geo.fitbounds: 'locations'` (and `'geojson'`) now correctly frames
+choropleth and scattergeo location traces containing features that cross the
+±180° antimeridian — Russia, Fiji, Antarctica, New Zealand, and the Aleutian
+Islands portion of Alaska. In v3 these were mis-framed because the underlying
+bounding-box computation (`@turf/bbox`) reported a bogus whole-globe span
+(`[-180°, 180°]`) for any such feature, and the fit zoomed the map out to
+match. In v4, `computeBbox` uses `d3-geo.geoBounds`' widest-gap longitude
+algorithm on the feature's vertices and returns the compact crossing range
+(with `east > 180°` when the range wraps).
+
+Because v4 also flips the `fitbounds` default from `false` to `'locations'`
+(see [Geo subplots auto-fit by default](#geo-subplots-auto-fit-by-default)),
+figures that never set `fitbounds` explicitly now participate in auto-fit too
+— so this antimeridian fix reaches many more figures than it would have as a
+standalone change.
+
+### Which figures shift
+
+A figure sees a visible change when **both** of the following hold:
+
+| Condition | Detail |
+|---|---|
+| `layout.geo.fitbounds` is active | Either explicitly set to `'locations'` / `'geojson'`, or left at the v4 default (see the opt-out list in the auto-fit-default section above). |
+| The figure contains an antimeridian-crossing feature | A `choropleth` or `scattergeo` trace with `locations` where at least one location resolves to a feature that crosses ±180°. |
+
+Figures that opt out of auto-fit (`fitbounds: false`, an explicit view
+attribute, or one of the projections listed as skipping auto-fit), or that
+don't include an antimeridian-crossing feature, render identically to v3 as
+far as this fix is concerned.
+
+### Example
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'choropleth',
+    locations: ['RUS'],
+    z: [1],
+    colorscale: [[0, '#c33'], [1, '#c33']],
+    showscale: false
+}], {
+    geo: { fitbounds: 'locations', projection: { type: 'equirectangular' } },
+    width: 700,
+    height: 500
+});
+// v3: fits to a bogus [-180°, 180°] span — Russia is a small red strip at
+//     the top of the whole world.
+// v4: fits tightly to Russia's actual longitudinal extent (~19° through
+//     ~190°, unwrapped across the antimeridian).
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 Russia mis-framed with empty space](/all_static/images/whats-new-in-v4/migration_antimeridian_v3.png) | ![v4 Russia tightly framed](/all_static/images/whats-new-in-v4/migration_antimeridian_v4.png) |
+
+---
+
+## Geo subplot zoom limits
+
+*Implemented in [#7371](https://github.com/plotly/plotly.js/pull/7371).*
+
+Geo subplots accept two new attributes for clamping interactive zoom:
+
+| Attribute | Default | Effect |
+|---|---|---|
+| `layout.geo.projection.minscale` | `0` | Lower bound on zoom, expressed as a multiplier of `projection.scale`. `0` means no lower bound. |
+| `layout.geo.projection.maxscale` | `null` | Upper bound on zoom, expressed as a multiplier of `projection.scale`. `null` means no upper bound. |
+
+```js
+Plotly.newPlot(gd, [/* … */], {
+    geo: {
+        projection: {
+            scale: 1,
+            minscale: 0.5,   // can't zoom out past 50% of base
+            maxscale: 4,     // can't zoom in past 400% of base
+        },
+    },
+});
+```
+
+The defaults preserve v3 behavior — figures that don't set these attributes
+are unaffected.
+
+One init-time wrinkle: if `projection.scale` falls outside `[minscale,
+maxscale]`, Plotly now dispatches a synthetic zoom event on first plot to
+clamp it back into range. That emits a `plotly_relayout` event that v3
+wouldn't have fired. If you have a listener that distinguishes user-driven
+zooms from programmatic ones, make sure it tolerates a single extra event at
+startup for figures whose initial `projection.scale` is outside the configured
+bounds.
+
+---
+
+## Shape legend marker outlines honor `line.dash`
+
+*Implemented in [#7845](https://github.com/plotly/plotly.js/pull/7845).*
+
+Shapes rendered in the legend as filled markers (e.g. `type: 'rect'`,
+`'circle'`, or filled paths with `showlegend: true`) now draw the marker's
+outline using the shape's `line.dash` value. In v3 the marker outline was
+always solid regardless of the shape's dash style, so the swatch didn't match
+the shape on the plot. (Line-only shapes — `type: 'line'` — already drew their
+swatch dashed in v3; only the filled-marker path was hardcoded to solid.)
+
+```js
+Plotly.newPlot(gd, [], {
+    shapes: [{
+        type: 'rect',
+        x0: 0, x1: 1, y0: 0, y1: 1,
+        line: { dash: 'dot' },
+        fillcolor: 'rgba(200,0,0,0.2)',
+        showlegend: true,
+    }],
+});
+// v3: legend marker outline is solid
+// v4: legend marker outline is dotted, matching the on-plot shape
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 shape legend outlines solid](/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v3.png) | ![v4 shape legend outlines dashed](/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v4.png) |
+
+---
+
+## Overlaying axis `tickmode` defaults to `'sync'`
+
+*Implemented in [#7684](https://github.com/plotly/plotly.js/pull/7684).*
+
+An axis that overlays another axis (`layout.xaxis2.overlaying: 'x'`,
+`layout.yaxis2.overlaying: 'y'`, etc.) now defaults its `tickmode` to `'sync'`
+instead of `'auto'`. The overlay axis draws tick marks and gridlines at the
+same positions as its base axis, computing labels to match — rather than
+picking its own auto-fit tick positions.
+
+In v3 the two axes drew independent auto-tick grids, producing staggered
+gridlines that were hard to read and left no visual association between a
+gridline and a specific axis. Sync eliminates that overlap.
+
+```js
+Plotly.newPlot(gd, [
+    { y: [1, 3, 2], name: 'A' },
+    { y: [100, 300, 200], name: 'B', yaxis: 'y2' }
+], {
+    yaxis2: { overlaying: 'y', side: 'right' }
+    // v3: y2 picks its own ticks, producing a staggered grid
+    // v4: y2 places ticks at y's tick positions, with y2-range labels
+});
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 staggered overlay ticks](/all_static/images/whats-new-in-v4/migration_tickmode_v3.png) | ![v4 sync'd overlay ticks](/all_static/images/whats-new-in-v4/migration_tickmode_v4.png) |
+
+### Exception: categorical / multicategory base axes
+
+When the overlaid (base) axis is `type: 'category'` or `'multicategory'`,
+`tickmode` continues to default to `'auto'` on the overlaying axis. Sync'ing
+tick positions to category slots is almost never the intent.
+
+### Opting out
+
+Set `tickmode: 'auto'` (or any other explicit value) on the overlaying axis to
+restore v3 behavior:
+
+```js
+{ yaxis2: { overlaying: 'y', side: 'right', tickmode: 'auto' } }
+```
+
+### Incidental bug fix
+
+`showexponent`, `showtickprefix`, and `showticksuffix` values of `'first'` and
+`'last'` were previously ignored on axes rendered with `tickmode: 'sync'`. Any
+workaround for that (e.g., forcing `'all'` on overlay axes) is no longer
+needed in v4.
+
+---
+
+## Sankey layout algorithm update
+
+*Implemented in [#7830](https://github.com/plotly/plotly.js/pull/7830).*
+
+`@plotly/d3-sankey` has been upgraded from 0.7.2 to 0.12.3. The schema and API
+surface for `sankey` traces are unchanged — every attribute that worked in v3
+still works in v4 — but the underlying layout algorithm was rewritten upstream
+across these versions, so node and link positions for the same figure shift.
+
+The most visible effect is that links tend to be straighter and cross each
+other less: the new relaxation step gives more weight to minimizing link
+travel between columns, so flows that previously swooped across the diagram
+now run closer to horizontal. Node y-positions within a column shift to
+accommodate this, and exact node heights / paddings can differ by a few
+pixels.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 sankey with crossing links](/all_static/images/whats-new-in-v4/migration_sankey_v3.png) | ![v4 sankey with rewritten layout](/all_static/images/whats-new-in-v4/migration_sankey_v4.png) |
+
+---
+
+## Sankey node and link ordering
+
+*Implemented in [#7873](https://github.com/plotly/plotly.js/pull/7873).*
+
+Two new attributes let you override the automatic ordering that v4's d3-sankey
+algorithm applies:
+
+| Attribute | Default | `'input'` value |
+|---|---|---|
+| `sankey.node.sort` | `'auto'` | Preserves the vertical order of nodes as given in `node.label`, disabling the layout's default y-axis reordering. |
+| `sankey.link.sort` | `'auto'` | Preserves the order in which links are given in `link.source` / `link.target`, disabling the layout's per-node link ordering. |
+
+Defaults reproduce v3 behavior, so no code change is needed on upgrade. Use
+`'input'` when you want a stable, deterministic ordering across renders —
+animation, side-by-side comparisons, or figures where the input order carries
+semantic meaning that the layout would otherwise obscure.
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'sankey',
+    node: {
+        label: [/* … */],
+        sort: 'input'
+    },
+    link: {
+        source: [/* … */],
+        target: [/* … */],
+        value:  [/* … */],
+        sort: 'input'
+    }
+}]);
+```
+
+The `sort` attribute is not honored on circular Sankey diagrams — those
+continue to use `d3-sankey-circular`, which has no equivalent hook.
+
+Same data, same code — only the `sort` value differs:
+
+| `sort: 'auto'` (default) | `sort: 'input'` |
+|---|---|
+| ![auto reorders sources to reduce crossings](/all_static/images/whats-new-in-v4/migration_sankey_sort_auto.png) | ![input preserves the given order, crossings and all](/all_static/images/whats-new-in-v4/migration_sankey_sort_input.png) |
+
+In this figure the source nodes are given as `[A, B, C, D]` and paired
+one-to-one with targets `[Z, Y, X, W]` — a maximally-crossed input. `'auto'`
+flips the source column to `D, C, B, A` so the primary flows run horizontally;
+`'input'` leaves both columns in the given order and preserves every crossing.

From 134e90f9c13dff808a3fee2f8f81d7550ade9bad Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 22 Jul 2026 16:19:12 -0600
Subject: [PATCH 08/25] Move images

---
 .../migration_antimeridian_v3.png               | Bin
 .../migration_antimeridian_v4.png               | Bin
 .../migration_color_heatmap_v3.png              | Bin 0 -> 30542 bytes
 .../migration_color_heatmap_v4.png              | Bin 0 -> 30434 bytes
 .../migration_geo_autofit_v3.png                | Bin
 .../migration_geo_autofit_v4.png                | Bin
 .../migration_map_autofit_v3.png                | Bin
 .../migration_map_autofit_v4.png                | Bin
 .../migration_sankey_sort_auto.png              | Bin 0 -> 34609 bytes
 .../migration_sankey_sort_input.png             | Bin 0 -> 36483 bytes
 .../migration_sankey_v3.png                     | Bin
 .../migration_sankey_v4.png                     | Bin
 .../migration_scattermap_iconcolor_v3.png       | Bin
 .../migration_scattermap_iconcolor_v4.png       | Bin
 .../migration_scattermap_legendsymbol_v3.png    | Bin
 .../migration_scattermap_legendsymbol_v4.png    | Bin
 .../migration_shape_legend_swatch_v3.png        | Bin
 .../migration_shape_legend_swatch_v4.png        | Bin
 .../migration_tickmode_v3.png                   | Bin
 .../migration_tickmode_v4.png                   | Bin
 20 files changed, 0 insertions(+), 0 deletions(-)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_antimeridian_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_antimeridian_v4.png (100%)
 create mode 100644 all_static/images/whats-new-in-v4/migration_color_heatmap_v3.png
 create mode 100644 all_static/images/whats-new-in-v4/migration_color_heatmap_v4.png
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_geo_autofit_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_geo_autofit_v4.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_map_autofit_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_map_autofit_v4.png (100%)
 create mode 100644 all_static/images/whats-new-in-v4/migration_sankey_sort_auto.png
 create mode 100644 all_static/images/whats-new-in-v4/migration_sankey_sort_input.png
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_sankey_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_sankey_v4.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_scattermap_iconcolor_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_scattermap_iconcolor_v4.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_scattermap_legendsymbol_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_scattermap_legendsymbol_v4.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_shape_legend_swatch_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_shape_legend_swatch_v4.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_tickmode_v3.png (100%)
 rename all_static/images/{migrating-to-v4 => whats-new-in-v4}/migration_tickmode_v4.png (100%)

diff --git a/all_static/images/migrating-to-v4/migration_antimeridian_v3.png b/all_static/images/whats-new-in-v4/migration_antimeridian_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_antimeridian_v3.png
rename to all_static/images/whats-new-in-v4/migration_antimeridian_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_antimeridian_v4.png b/all_static/images/whats-new-in-v4/migration_antimeridian_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_antimeridian_v4.png
rename to all_static/images/whats-new-in-v4/migration_antimeridian_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_color_heatmap_v3.png b/all_static/images/whats-new-in-v4/migration_color_heatmap_v3.png
new file mode 100644
index 0000000000000000000000000000000000000000..dde01a9d0d5369c66906ad0d63f48197514f302b
GIT binary patch
literal 30542
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
bUC0ROvyyBUC+EvR3Bo5~$@fKqS|0x&d(orn

literal 0
HcmV?d00001

diff --git a/all_static/images/whats-new-in-v4/migration_color_heatmap_v4.png b/all_static/images/whats-new-in-v4/migration_color_heatmap_v4.png
new file mode 100644
index 0000000000000000000000000000000000000000..58be65175b5ef6092e713fcdcbd21e734ea34a7d
GIT binary patch
literal 30434
zcmZUabzD@>_wZ>11SAxYRJvh7kOq<NTpAQXq*<k5NeSte2I-LQMwD7oq#JfYy1Sms
z$FK2wJ%24b%*;7+&Y8LQyytANs<I3&_CstWBqUrp+2`s=NGMH6NXQ;{Fn|{J1`A6h
zq<ctm&m}ZnkT+*BO^8ORF?a30H)9rsR-9;0f?j>FHV9(!^&*fW^F_Va?vo#sk-;P>
zjwYc-Rv{6P!K4tWb!?rPlj9z7x#LX#W+a|4gSOtIoU`72XLi;-y^*ff-8t9|^+wGb
zg*XEVok<)STUERR#ch}RzrT@aQ2zV0(DFtu)jnankOKbytLwJ3xF3vbVRS*+EaAUl
zznUx1NO#S3?LVLpml=3JVZNQu8-<Uy&3oM3={~vq|Au=XVU<bM&;YFujtQq_|4hnc
zKaO(OWhW^dN4*V#JeK`GjWSMwSs$c})GGe!S;miioPhG}ahrFo&P2W1Z<UzDeLfMI
zwCQVpp9x2x6wCdY7U+O%hx`(v^=pkjzQhX+Kxbb9pfgvv0nV>=-!8yA4x4MC`a7km
zYo&GT%E`P}#6YT$X;(O<^N&QY>oXZcj>nIe!sAWNuvOax(XUUJ@sFN(9&b(xlarE>
z1qV_?Nm;dvRblfk%eZ~1Lg3Vv*^X#>h28a{(z%j{z*KoPkC>QbKa&#?`Q@d#VK+MO
zXs?D`NSt$-c7`t5b{g6kACG28_-$M2ay<8Ozi-m!Ug~RborV@pEf$^*J;&nU;5eyD
z`()s<GuQl)>%}uQ+wUy3IrM>x9f8Y-Ya>kSUI#1vJm_|3HbSDJR1qS_I#8|cg5t7q
zyEn^v)t2b^`1sbd4NnH8LeC(+Z1-6-^SuH6dS99Mt`3inliX+3?#q*&lM+nD(<;(_
zUt8-ucmJaTGWLW&5~@-1gwm9CwnsPgbTQCnCGmB}_;hEc1s7?V8SH`0cBIhHxOfT<
z!v?fvi#f`BGjB(;v*|Xcs$rjwtfy;m-@JMAV6-_|{(Uo4VH*DPXHbpJ^vjFmtw>Y0
zRY>d2wa|9sj;QP|iy5s<_}8omQI?omB@ws7wq&~&*J(EaRu@;-7rn8}787MJ1|AP+
z05L^pLarv=?gLSJ&$K%VHZI6gB_ks<*N?(4fnJ@zSm{eNKhwxlmRkFsvj>k+c}!3L
ztyq!6P;~DrkxrS3k1o`Rr>Cdqqli0Sn&+{u;{_3;a^Kr3WsU?qN<re;2FDI>WYjYI
z#V-a$`mNCB^Gv4c?a`tHLC?dVY8oQ-DNMCSq;`3cQ4EO**riST*wCvZu*cQW`1-k-
z(4g2&)A?fR$B#jFtyd3jF6M7&Hau5Toq^fVb^BtkuTG3TcH1%6vAo%YtS7jvXX=JE
zIfx)~_WSUjb;M|bkz3D?1iO|q41w7k=rJAg*e9tFnyf?-_hU`Y5$NHt%pDvY9xeSw
zr_XKz<FO8JmzKVTSYDT#cKt}Xq{#LSy_UZ)69Rz*oHlj*{rzR5q}G7I^fox(oNI18
zXUm-=F{rUlOyX2l5xe5eRZ7O-9x#$Ao^#(3*_<dxt(Z46te6+O*yMRGB~_s1ygd_~
zU<}nwjX&<aj`gG?tB5e0g}h|wN-!9UN96PoDhLGR7;?6periZJa#=)g%Bzw=*<=Nm
z<ZrdQ9TmFC8P%}%OmIvFaLb9ot79S~GqzC+PQH;ClZH54U%ECOPg&jD=%V&A5DCaG
z(TvnbrE-N66zf(>n=8E;{v@^Tz;to#w876FYx9NBYk5P$sAEv%B*l{JRrkGacEvNw
zqVHn$N^(Z{lYGGo3nsE&f{yF2dgE;r(?w@_IX$CH^*j)cj~UWE_Jj2}%pi&dJp9zJ
zgb2}2)<$G-Q|8?^*x@sn`*U<Q(IyuwFC$O<<zg5LO0}@Eb13(rPK`0qzE4ZSY`U-6
zO4(h*dae_WyUW>1+czEeh0+d$v@1(#TaRJa4YL>EV@I+)#1Z|4yeRD}uds(tuu0-h
z$bnN7Tj%!Z@tZnWhxf~GJIC;kZQ^0#QM84T^V1*)a(j*BDm{h3gWRmVmGk`2zIB3J
z;}@hvUEqESD+dbu?X(i59v|gZAKS$fs`g^WIn-0i57F9n#<79}Jn|jazN3rXTvk4`
zCf(?+Y}#|)oFE`<Qn;6xl!T3y5r*s!=eL`qh<=p~{w|3xLKjjf=WB5`6oW5zmQkuz
z^Z<^kgJMigO)XnSFA>?)qu~DIy{+ii&dyK3L1C#{<#7i2Q3O``?6veYIQa=E9qy-S
ziyD=ov27OXt%S0yTWM~lUH2`kva+&)nl32D8?jY8-<c^H7%5^>_w7@C#lhQ1cS=M&
zetEn*Th2~}7oB)3^vbQo5z%+L5955a<qm9t(PhbVMvhK5LXTcdyJS9_ANzC7?nPIT
z8Jw?as=aQYj$*KyZ`OxDhu0lmH(^#7HaeYN9t@6Z!Q9NedV_<LGKIUjnIsA+T9??n
zlA>`H*v!a55Vo#niiisKH|Ykx2?~1^5wo+ikC4l)!O;$I^_mxo>Kt<G@|1F*3T6Z$
zR|F|H3M8dBI5g$3XYa8@N>lDvC10g_$H%<9nh(_cr1w0xs>gp2DeKl|H;t8YL@rCD
zupK3g`&omHB$qfP!q^%uM++&e`jc#iGLYqCnW8poFa$ac4Gl*L7K*3p^WaBfwlhzU
zv@r$n5ZLP5daC_jm3^<<{V*jJ%^G)FZ=gn_O0E_7W?s2@c}0wqgcf|3KknGt+C~ys
zYJ8(0LU%QIZCqVt9B${@8Z(~Mv;rT)U2AN5P&wW_x|cFvZfS7sv{id}1*;QveW2hV
z=5fjepNJeUQ_j;kk#cdV(|qws+y{$mft^dfM0W0#)sK9i{$&2-7u`)WsEpJt>NHsd
z`zr#_OP3=*rF}>)1ko#j^7Kr+S2zBx5eltqR;)rM2*f%9g3!_$tApn>5vZ+>8)K39
z&#;8)?vV0YL_WN0hX3Uino0{XE$!fU3@ivd?D9u}Mj1T4wYBy9+sAzbjFyH*oN_p>
zElW97Fmjj#%ffQ380$@5=wT0Lq(k#}D3<g$xowhIaTSg{d2g#?+Cd12hPvWtV;sEW
z91HEavl4(yPIDD6=t^I2^Bkomo?ZXT$OsXkPWR6SwC0zw;~?iG#*IXt*LdfLYgysp
z3h8tUG59|!%wTg)U#|iA>lWD_cY3ixtF)9k;Am1)j}b-S(ttx_>6eH!m9vc4WjSGl
zPK;Y89c{Tfn8Od&oQW^I>n&K}y1O7@8t0Kt9~tY(-0t@j))IrxRvx>2d3~`Hhz9?T
zk0nj-65pmirgl$G+A_y@iB-CSeX_GBhVfA?b2s1DJh!9u$mzgrF~}$SQlI0kX@xz?
z9HFCxWgTBTfn3DLnBhtD{v-)y--GG0Ln+&n$QT(@5v)T5os2SHsH>|8jH!%*oDi+I
zoc4mV)NNzzvtLRE>>{)-IJl}>G7!&IiyzT*Az@%Z@d|D*#|p2DB*G9_<kITpeq;;k
zHB#+zJRXGwS2xwbziO4Z$cn)~CX8n^JwQBpQ_Oi`EDWI<tQFF>8;9z)HjS~n-b6Qa
z(lK&Fd>^BtL99MZz^a;B9&j327k9qKCJqvBLALX;_F*k&^(irITms@Yz=KJ)i~i}w
z!JycqGZ1Ii<9#1CY73<#-l$^z+^K4-<n7T$Gx{8H6eC2>AtQAO$n@?jgnE9cZ#N(P
z{71MS*mwA{rI?tMG+%p=>SG~UtxIH^QQk<RyxCV-bGn7N*QTJAc@FV7{EC$6cp4pF
zhvf#iuIRgO+8ourO*wMX56uM57HZ!mUakipRa=eIZ1w1>?Awz3?3Rt#Bsv=!sBh|1
zu;&;g{MlQ{-4pyAc%DC^ZRiwsjrUeKXBq)~T}*ff#?;8o+4>sGa-WqyzQ?ITzxOjM
zD4N+PcMlHJsm)0HwwxJA<r@<d^Ck}RotdgLhBs9?FYTusIh;;j8ijrr#BPsCR3TDe
zThN+9^YrP{?#H=w*R|x$L~kc$2oHOGAqFrjDHQX>LC)a!AK_q`UO0A469?jm?x2%y
z2d8tbDGebXMv+eKb;%8XF1WhEQ)-5NUN_K!TOUWW>Yfn`+fXtJ5h#rg{v7*S<v(X#
zZ*G8;6^4?=FA~ZP(hy%Y!pB*(3cHJwUfn#gogwX92KU2J(XqvEA2~FT`?@HQ(q!d4
zo-mFcrWiEjXwGUlq&#%0`)5cW$@6Hn(WWt4pBOl~m;s`qu&U!DJWZZC0bkuU{v0IF
zk|lg~aT18u4H9HFi_cA=P7^dV-(^h@sw|bvgY^xHo<Fv`hJd&%hG-lQWv3FylUqV#
z&5RQiVNM9t&Ixc2ED=ukd^<f>&8ogsdyJD-L||hU)@0BUkDy<OUft{&9K?sff)3A0
zTdzU05iDC=7$%UHk72!mM#pAhBkCN;fyxPMulo{S>$b+is<?wg9Hvf-N6a`_x42di
zCkBO@%*=cW@jCMN9*MoDhrzlV3|u3j$)A5xnZsS;^x2_j2ofHJy;zz)7Xugr{KNau
zm%SEAq3f{xGWh%(!g=4_gqqb_8?yJY(?0Mk$@QK}v|f-p=fN5MniUiQJcU1ZV?{a4
zow7}HE6=a%8u0@!-^}oAJ=?@cwF4Xyj+w#+w{#B)s_{<T;4BJM$R_zg=wRoG)Uwt0
zkDOgufU+Kqrdr4D(5-|co%3sY$1u5YH8T51Q$F`-BFeRda;kJ@)q6m$gYztEg9}U6
zgpn4flhdWU_OsbxJ85<gW`coRyn@~2`~ux+WE59V%mtwmE1NggGG+#v7Nnl-bu_HM
zf~=nHayde*(D->2CwdQpk1R8$;*0VU{Rw)nnfVz?puu&lLS5(Z`sQ>(2KPmiq5={_
zz<ws(fj~@b&(<SIJvhzml|08y>&14XxfZ=e{M|DeVB>uV59d=}xnOIL)Qt32NULOg
zQ;U{SfqT~3I1^x^2;?bhMZJMlhf=9M%MvKWZ$b_kUzZmf#}6hN4;@t4a5tsqScAhw
z>Sx$b`g(29A^7$KY8C~~{Bn6C1t$f)39%5W5fEqXD(N^Y?GA)BDCKKUbH^DOc|y-d
zJ<}D!$gMoOruQPCZ{uAeBdcrmmhu5yr+=e2fWkPwSfNC`$3_>DUP0jwQShsJQfh{%
zYtl;m(W(zlRmQBBVkjL?<~FIK^G@J{I~UKDTsiMw(@%pKCUZk8V0%eCJxK2X!+%z4
z<D2gA9_Kqr)~eOpwu#{!kQJv%z%`qjFd-xBIqPIN5KL9RGDA(|GulpQ)8S}+n9w}^
zy1tl!RvJ{nM*CbKW)JnnV4BE!jtf>NJWL0L=Z)mRR<9iftl3`RV8_hJ_9AjYd)qHY
zVHxy=c{)-dT40<t!3{xZckHp8pz(@w@*r#kf}dtE6-!`M-^WI60_0l)7mQ~Wp`lIP
zz=5?xPo5Vx=qk{CY<8$BZ4r7DI{5u#zJ|<i79c%Y(+9(f3|%0LnYm#<Q|ADq!D~np
z2NU7yd1xsDGV+KH!zrc>Sbg8tN)ENUOcUbFsYe~Qx#8gG_}(MNczYur*3k*7ryh;o
zk|#eXWIUl$D2qAx81K4l_EJ~5ghKdmNHUU>SF6N8_bQRylpKDhy^&C{S-^E!St@o>
zHPb?Kp|`CTH?8tY)cvek8CK4+qaomDboOa6wOC(T5z&ae-w^Abcc53p6=79RVr--@
zP|NBHndxyi9;monF-uJ8THl)TV%#yFtYxpQ?qRC;pq2=q+?3m|7)S7;Zv(htrx_b^
zW`MGv$wa*goJZ~19!%t{J;^%9{7;svfOln&d$1-nWJqhK$KG>}`~P_e%K(9E(6T_=
zYDsg_Bo}QQ6PfNFjjyF!i*^U}nB5HYkhYcXQEMwROrf5;M>Z8Lg)p|q;@!Z)kj{>B
z8e-14-czE6nR**k@x<~6lk9H7TM^I)jx1^jv%W7S)-{}j9{%;&-M3>2u9MXJ5)4-f
zG~g-rTK;bS)ts4+uYSm{%O%!zTO?G;K}-5{x=vFP{B(Lq_Fug+sG$!BH86?c(oe@m
zsV(mVk9N<x@Azl*IA?8hwRY66o~uJ=pRL2Lpb(FqrbGR0f`kky6g&a7NKOp-W+Azk
zv=R+E-GMt>C{zWU(%)Mz+05W7Q=H-7ozDov4UFPBE6Ao9B@!+NiQz5@SDdZpFW6w$
zY*+DZTF^ytX`--%K|~FOKtXH~5oAU_S^-wUUa!fv5t+Um&8gd?qSe!MDIa{OR$|`W
zl&$~SxVM6_06cU(IiBvRSAxN7GerzZj<P<{?s7Ud+kT}NeqUfOItICZR5DzvzVI>F
zX<t7At@|a*g+htHY$R)`*qc(c09SVXk6qQ5ps>sNMfkW0yqaMv##BT45W)A*Rjj{A
zY4X7K_x6nQY=lUuv_#O<M)h2jQ?y1yFShu*^Bs;GQgYjx0T|N^mf%QN5WhV=h~;S>
zXMqG~Q;h>+k)HcvF9(^Hgw4DN@UZU<jGYN#kSJ+t??sql*@qTI8w*ByEA_(3J0SW#
zGZ>HTRyqau*{Eapzu}XG#T&bGUGsg8owbQ}><#>Y=C;3Oc~-zy@6TEbg&X8~h<9Tq
zUKS^zCF~Qu06|!hAp;Gau4L^oCK@P|0#T9aFQTt#r$^Q*jw5CWA4#-?vYl*AgRji6
z&TL+uaos0hK8Nd00p9n}(66CKu7CO=6YUKlvFx<j<Yn~C4hu|S;gJ{tJ+%j+B56XD
z@EKutmBzM6tiCuMO*9c385#dr<)JPLif&#gA?)hozRk&HeDx1?Wdk_heeP%?4l<v3
zKA2pp!_{{%nNJLC5uzW6#@bo2IS82qE7CoUcegi7m#yFA6cC6~ldcyt3OB^EK={ik
zhr$crr+9SdI435U!J#UXX`v|({gwcSudgb;)QY?o032@AQq9Texv$rqW_)jCpNhxp
z+M`=8&A>H!yyCRCM-ti<b$R#^t-eA9@ql12@_aujPM^qjly7pp0w3qRE?xr7l`}eq
zv;M}|)+~z1nT+jTt9~`3drMB&`sXRm9rXAXFSGd)MVNbJlQf*a50OWRAdQbvalJ`^
z;L<s@%L9;4uP1y+j|T&fBLAAY2LqqVT5bFlu^LDHLsl3&IwYRcCzYFXwek`k8QM*1
z=ff4RU{80pPb7W&W(T-3Hq>0U-eb2r(3d+hW|$9)DqArcEgI6Jbe)GeIn6+AyWh!a
zHw2+Bo(Z7YNI2imWEh!@DOT97>`P-rPJ+WK;jrXJG`(m>xt2}3_D>!~Mkvw+rizd?
z&2xs6_wutj3JHa+2+PgDa-)IQWJ*yqM)6TC3cK{4@uIQ|uZlSnWX+yyO9y3_phfRn
z-LHs%*ZPDV*&;GV)_&Yz`G)rO?h}55@lUa1IfZRJ(7<|yAdS2TLx}2_CZgFwAdj;K
zDxhmO8>Ou!*La2H;leNwsE`xTaH0nSNg+Kz@I4S9h!*V)j)KpxpGJce*bp$ECAR5k
zQ>nXfmuLj=iXkU}k;C~NjAamJCXkMBE}@r=J0g>@$_aOo&EPnZR7j*-3kh|BU9EvQ
zC8B;jVZidwF6~@a*|)2PGQ-kdxyPT*uOHEHNH1@0^jqmoF>fVs>aJ*|y(O=mTCK1)
zG6P;~2j_b>jE<uyP9R$H%1m_k;t_Cv*(sB|4Tv<|`Y$xD(eTrlbYz~ncv{#D%l)qo
z>=y#77oSp|_gutQ$%NCMeTJvB@<q+>v0cEOx(W~1v~TlQ)>6+~BN^`zxH}|>c3(&C
zK)d-8nN(G8-;m^^H!|C1vF!zZb6#xV@nDy^4?+A!);cV0Zp2J%$QVt)yWo-fUzV-&
z9^jTm6S&s?2$W+(o>KRPO@067ykA&(#t3-IY=!Cg{X*X+o+#D?=u9T%z>tsvov6P+
zyzK!x>F(5$QDsyAKTvrS7+yL{je>T|%}wx8Hfe#6K|tXx*PY6p->Rv$;oTDP>7JC|
zFdNWrC=HOYwWV<!1PB36IeXXJr6mFEx~O2bXW)N?{g$f3iR&)B`B#&ks{Dc3Kr<_`
zNt@Msq4!FkkkG9ayg%psx1fy&K<n&9;ODIWVRLVkn#U&9Td&%zsv84v|F#k{-2qI6
zp4sgPNQ%cPWBA3tGlGC+KHz@JFY`y%bMJzmx9C0fN$vALjZCU{fmMberzU56|AX28
zoYucp6<@@$$04r61Z16fcS-&4F5uQM#m0c?j&^8khW>&4-YE5esFlYrFn+1iHikX{
z#a5+h^!|oy_xg&+q!;v455n}Zg6xM2s$rrchG9|*PA;1tUaBaDM!dvESFR5;EMqcb
z4d`eg?1AyI;_iA_GBVI3NyFTm8Aju-nmk_x%mrnAk!XWmHu~2^RDj^A4kL5w|8%4g
zLyiaTLmrX<?%1R3+x~ku;tn)ftq}mh_WP~`;Lyy#Ee3-#Ik^&GAmE~+4!9Zs49@_x
zjvbRu1MvK}JMCpq-V^W6sgdg>{*5hfl=nc_+98Yjm$w~}f_~kYeB%HbC!CSVe|^1`
zSH-ECBJ!$DKjnOe@9%|$cqR^jciz3U1;Xl|8y9p=VElqoz4Tw{b|?l7;<p}VVgyV7
z)yl*MaOP*5h%%9X#}k(UNn|OyZ1J=I_4Iy%Q)WZl4LHv3T9oZq!2LIOnFHWoz82I;
z4;Z>m%<qL=+(u~nMQU^If3bLR-(-;4#QAn}*d|nV{4rl!%dO?duWOoW|Jhl*z{L)j
zRw#P*KP&ruAz07@95a1u{ELf7k-xSl?v?@c5q%m@QvSaf{_hT_`t}ZIOr*o<)^lZ2
z$The2_P&4H`X%)X!(V@56Q_tfpf#b7yOjk0*8Fx+wFG6s-s8hP1f`s$0a{V>FI;yG
z4j&%x+BD>BE#;=Jo0^_dRKkrrWu{XHvYe|QYJGK{?pjPFFzk~juPqK2*yu9pACA~v
z`<}3fST@%#8BLrz>NVY4S93Z37TDMD)b#pbqG`ua<Kcm_T_uEl;N8yHo%w+aYQ7RL
z%1U$55I09ya)ax<XIz=dHIC(E=o;z*0%6I*dLH~~^5vj1Zn;Y*jkP`>_PnC&!y~IW
z9vheAz^n3$gmI-eGpvS6W_l_1LmOQC1x`A9!zP<a{3s#wo*14}PrUbxM;h*zUv{ki
zs1R6A^REr8iNN0@9jRs4RwDKH%Ej-h;Ky7T);<cO&^go-qewbRVr~{{ySy6HRP!Se
zq}&}TQdy3HMtpP||D;Ew9q};8kNR$xGp8srHNOotb#6E-5jG~&^ZJd)m=Mf#vJLw5
z$@LSB^ZdpmDr!E0-D8h>oI?H*U$xJS3t7m<3&G>=nd-CH*sY$|XL0+THTQ2ata>tY
z-_i0;m2gd+G~siq{0tkB@q2r8aa5r4V&sD-=?^IO02O{`nVjd_(P2I5i$HRdiH(Sb
zcdD`_C9W3@rY7l}Lpf`Wmgk#(qxI_+>{$i^Vod_aGKcF20@@|Q-p;Y6-zK`s?T*_5
z!UFdWd5o9)5>-P<ZJX_eI{D@|-ku>DheEy38$?g&p+;W!cEYyb=;f3qkf%}b;eV!1
z&drTznX+IRS@QSuqXMp*NI_--g1E_HQdT$ZACb2fH{lsh&fjtHP5Y^3hF6d59QI$5
z&bie1C6$h1Vm4E)kzw4uzLcr*+_3U!bmg4$Xc9@G<Pq@@nHjp8MF$S8fTTIY2Hhg!
z`tu|Cy!ap`d2ZOvZg9z|<Bi(8#0DhBXC=#9b6fqr)xtcVY;5tx`1#+ZG$TF9>r)-6
zb3C#4AO@u=p*69)^R-t*K)<~=O>l7O;<nbSqfAY+0eAC`HM-4zp9^ZDGHu3X^NlwY
zB>&)StQQniW>NY1iM0`~8voMn#uqXBWjD4J#WP&oWG%mt<VszU&;14s_LM|jY?A)p
zS5rI>jvZtyWHkq@l?DfsTTuxJ9AxF>I%>AM7IQbf?Cik2+9lY}r5H`V4PMwUOADKO
zHQx`56$XPDmE1il;rRYCokdjo&Y10nYo)cXSGr?s33rY9_XNL#q~$FI&9AC()XIZp
zm6bYbuJWSd(~!OFoP|||?nTL8<0s?MJQk$liQj6ws%C8)om8u&V}7%C>T$&Jywl9h
zS|oN&?F-Cst1<%gg%Z+n>8Z^=bSk-3kuy|o>uCLy;???_%EJ5i$kM%coT#6>SPP5l
z)}ksEX?iC^?oVmTWf3{{#y-nS8ZF;;xpz09Soxfpb_V>(difMM4r(<`unYt|N9jC{
z447EPad`Wur~Q)yaj4v?n6-`5-lJbIEKim<Z-$AJ)#FOU5)Q#PUBolQN?zk^-|c1P
z(Z;f88E1;AEX-XQOl!(TJKu9X?vcW>Z87G-wsL9?Q)zh^^spMXqC1EI+9?cn+=!R-
zhY%7I#rRj4c@jKGa;(Uwpb83;dybH&-^tvGm;B8FEN5%#RGX6!KNk2IIOJ?vib80i
z*XL5!S1;&9(+|-swMLJvq_z(G1J6f$UoPEHN$(yp8H5B$)vJrHAN0RG@-s{+jIWJY
z&XPbNHSuTQl=#amTfQppU0B)lKiX;bZWSXB7bq1C5cJ8(Jo3VGqnz_9=3%&QK%aam
z6nk>gKANvc!X0@M@$)O4CTG^xa)(4-N8qfG>6ddwd^7EaQU)+1qqWx&ItA49=>w4~
z(sgv5oxK-C$fe036oOJT_QI0=$owWX_k>;b+|2{KZ^iu|g)Q(f_^1M@b3aSg`q&JW
z8{=Gj?H;yLLFmYZs_?;-lofqcuv99A-IH9m-rI5SpPi9j^uC<A6Vai+BWB4zd!i}L
zEfeNK3QM^8d^|Zaf*vfup~gU;*FMhqmRI3(_97-H;?>y^iO`F+UN6OFkFzZ^Qo(D?
zP&YgD$FXV)&eBdiac^8-c93wsXcxK~E>yek_!WG<jwqp^?paAFi-|2l1D&%X^psmw
z$Uf|J9m*uTY3;rTEm>`DWRSu3W?sX%4`Jy9R74T@nC7#sZ;G?3SJm)qJLg|>EO#TU
z%nc8m93`H~7wV?DdAL02I(gogq?XTPI#t`5c97uk^y`cy-}#Rv#Lrp_0gS6%o|3L_
zrh1$kBBIuh7nC$PxLsXdd(!m0Yl76vm2Gj;Gf^=fr%P6WzSJLeiA>Z(sFR$E?IM69
zgd%UEt|588WuefcyGxoLUTDQh2IyTYNO7|RGFO@R_J%;2N<;mvns36x-4v51F!Kie
zUmnC~SvoH-MMoVRqx17Kn#J<Vv5)WjxisClai$1T2ZRYlBsaL}CE|mn+al8Lwv*u0
zWE#Ao)>M`LqI92EaId@DZs_fyu*d$awuk7s8t-R)f^w|hy~USM_mE@|HD&45a@O*x
zz)wL3QHGmSp%#yN&ZP0e{Oz+0)^UOdlz|<qr7zb9g;ZPo`B~!kwP01JLo{4S>_y<O
zB+1UJ>qd&|kdkSV8N{jV(DvSNz5$Y+R!PvB5XAk?Q1H;kov@IO)^_mTVmxL3!bX@p
zbj;Ob;&~gn6Eg+ED)zqq6Rl!><mkMCU1a_*FYlEa#M7hSgK$&i#CZ=`EW$T~zMFZD
zdYGm)3$Kn2PW*gM$3i<d{7?)za$$Qm*fXj)bPk$}b|xLNupk@Dv1OC;J|+gWm+1iP
zYxi-#>ggk@m^c%#a4xiYE#5E|c7i2W5L6R$5;H_zJ^@|0i<gcq9S6CtBYYT)bW^<C
zp(`MY5{tA`5$&bGi+kT7B=lQN$Lrl4fp4^JV&K6~acvxr1nxsx?Mj}7y?SS*gX7p6
z*Xcza{-r#^sN*8SNjjply4-W-o&k2mGhO-&9;eaCVTsgM(#+W%*>|P-IF6|D%U|o%
z);YO7CO-4HjTMC%(gu){DGsUy%dOvWdG+!W^I#GK5L1R?cC2o#Q(BHO!?S_s)nAN@
zP6`f=PlvK4MV{6_Ei^3EY@}!q8-E}K-U6>~T`m4>Iq=4__@4U!ZhUghZqM<P<&)i4
zSn+HQ<o>1FXKn9-`N7ujSgXp0k_N?2GIVrx$%o3ubj;L!JBpXUGgH@j@yZzvdM8Mk
z#P_){>2TA5dLRu~vI_Dz!`xz5LRge^L}5?1qfSM;aK4-0NdwxPDINE{Q}-_A5XNf`
z|3`dXHWInm4?pIsPJyo=N$<YFX3_Ea3Vo;IU<*S9_b!XjT6!0K;&E9NxT!qzA1NER
z;GOv<CuOz=wnevC=w<m%@o@5!bhG0+qTY|FY>%v%x-VZ~w$JqmY?XrD5<c<#V7fEA
zuQ%pf|HZ3W<sany9kFoHx#~dQq3bNyr}mF@TyK!{#`}at)2zqtNq|dfL34tr!XZMb
zD&Ls(oeNuAOfK&S)Q;P=+jaR4nXd?IYDz;8Fze25UBW*eGJYwMl>QRtI(BGHguF9w
z-~ETNxz0Pw2M^FZeYRlNU*~Xd^kPh-YI3BP<xlrdYRgx86G+9p?r8U4QQmBc>So)N
zt%NDLKt&sb=ZIPHm82V~!nhAojf?B+-%s&jA}X#!Xd4z1KHI(c7SFF%V9D%pws!t(
z*4&}A$*mgXvfKXf=THj=bRP6zy2d=0<a%7$W@@5bY$*zOk(#y38WkK7o6lddI?9wr
ze76`W78I=3mNtVzDI2|d6bWYp1%K}KwmIqC%ogc1?%vnLV)G$8@ET`%KgEfON!f|J
z?cW?CZMqdo!d>Rh6Pn)qAdlmH0fJWS;=aiAkB)G=fULJ6Q>PZg51tqo;V*G#dcE$p
z+p<j)M)MQm|CWq1_V{P7WB1;k9<`Y`A||2yDl0)%i|pvi<(t!Ib)6rjnK<B2JE%ux
zJI&zX&uZ*VwU8ny*qid`7^8?<!J2P#<3^ogSw_!})UQuXVt&1H_WD$uHByplzI}Qg
zNA8PmcSED=lpL>Q9Fh5XUa}Osv~ZBMb@&)l6DoARfv;`aqj)fX6=Q7o5d^_H=S%Y*
zPdg<fQCV#n79AIS63y*Ch2bIQ99Y1g!0EsI8T??mTseIqctC^uO&>@$t-u$9(O20>
zDo~kvRsNuLw&0i##Dct|VidM5lD9lc5aJ-gt&YQcZoky`<mkjvUyQGR({<pxVI8T5
z<W+@U?P|;Oh<4)_n_Wdegu~SHXB%9e5Jt3C-|NRvl4;DW<a*Z|ak?Rf=#A9Fo(Ymu
zMOkok`I)18I*$pn=Xkng9?X}{;V=E^<N{~d<@9b9#Q}ZV%_ZZeC{$u=^K6Km^c=xy
zaWXb;A+}8(n$(C9o%dj>r-Sn%eCaba|3^1+f&_1F*jVOTHs{{qILv`TbGj?AV40s$
zn?mpdcM*@sfb>jT1~pWolFT^kY;}GCao>u@mA^=DHl`n~Nt>|?<9}%tFH;+bns^A1
z>Q&c)CmH|bpW?_d0Q4Y2XJjKWQTo$rA_R1_d2L*t^IuK~B%{{&07fCYZGFjK9`z?v
z^hR-JZSy{{MX(u%|1K-M{pSZYAOqxHdOLFaWmCbs`8G9G6$ZwKbfxP5lczF0MlQl}
z3CW+Ix%)SJ_D;P6B!w}Q{k8x!;$v*X01C^9GsKZ^OD1S!O9K8Tg&ACE+n%XFZQ^XC
z)jtVn*-Ie%)oyw_!3z`w{)HJc@&H=;{OaRx6arux6>s(dNkCUBrapk${H~ZB3cn>m
zn+nJN|A3gb@Y}3-c)%R|o0)KtETnkesv2?CXY`kEH39{KR<(_3l(m0rEs4v_0F`Q*
zP9~gwSy@~S+g_izOzk#JZ&;qN{$qP_WEdbvZ{@4rUj}rWFtgk)saj})^uL~fhVB3a
z&<Oz)wVEWd#{8puhIl5R5<9Ur4BVUakE7lLj;giytp6pyOwqggcD2MwNT_qqvJfAB
zuL-bXu|(UF_sQleyXt1ohpBsqa!<I-$Wl@_Z?Vos%=flfvxQwJfcV@kY#~Df+BmYD
z{g`13abPcWjrjIHl2u=3n8`@nAkfj|4VR4r0B5juBmQ$5wz0SVFF(Nm=Amc%?OzSY
z=uOnDfYz^H<^R#Uh6P|Y+9wp#0LjteX!|w5<hCGn%k8A{;CIi781LreIONjiZP(-E
zKLIik4A@6#a(I&g{cnJK*8m2#wDPLp|2>#E7HK?-3@~ugWZdSRe@tlvh&fPyLG{mQ
zz&-{5go)ds;rq2FCKGZLYkKrz@GU*tCa($oBV9EE36S&v=`r|4J(AU*0P*<*AVK{f
zOEXlzBq3!W1DnJDc5~cIPW~qhncM)Cr0i_Z9_ao-IM}KSX@KeGcpia&L8$laZAZ8J
zqmBgVeDbNw>|akBiAy4vj_OzX{9Y-5QN95MzO|%7^>Vj?^q!?H?!VpTod{Tp2k&3X
zX(81%fsfH7jV1bDk6+uvLLFEpgEOlTP;>mp9T|>*Y`yu8&0qD&z`Vp|&&4|&0W-U-
zR#^Qb91uc<4$#%qJ7pZdR^PUQR?N3Rd10cTLeAY8TO%wq;Xln%_LvWk)Ssv{^y_}t
zd3)ElQO(>@tk$g8YNlroGz#k+A_|HSwOjlMg;aG+Uqv&$H2da<@4ZJcRh{}JVlS^g
z78DJ<;AU!sh_P^7qUMZK2XH*;*UUv=<*{<_>OzS{#i;yN&qs1g+-@K!^sT2|vBFLU
zTybw4zT8VeQWQuM+QQaoEQ<GX#|S9sGC5rozRSF3*`iIY&cV36?jKUGzFEUm4I{uQ
zNsN;!ZO&Y=I(xKeDd@Yxu+aL(;VFogD$`wEaW<^+V*u^Qa=EiLn{uC=xLZX#u!`XP
zdz4O4gujwTN;!h)b;|6P$@+SDqVnmQ7Fa{@G$yM+v5069Ou4tbO20R`3pssbj%Coi
z@M_(%+m(^+G=n#{Ssf4dI#yghdf;}tqDKR#9(ptZt(rtUdEmD92fEzjhXwcdmKFqa
ztE}b7ip<KUyvOJJDedg0eG7TSG&ELsNRsY}ZOz<g4X2ivet+Pw=|(!|p8ucVa5?6>
zu?kUTu~A*6goYYk$5G&Ich#*{>mcXy9JLyNSgH0cRDOhBXpcS_+8As(ihU6p<8iG1
zQL`NMSpzTOqV~D`8_v@m0aKQdb^qn+r!KYvfpr|C_hw6}mKsL69JSIveh4DjmOSlV
zvHakbUs0eKLe#Lo-FAAu!aPJ7pl6ggYv@Sk(nd{cgcI4IUt+#ubvP_Agl@(N1}O~0
z87%0HD{VPQdtk`7YRzeGk4ToQDO6q9J2-+oHlAiIZlvY!6|-`bDoM+~3z%9QnP<#Y
zWPLruKa84opVHnzD>|tZ5h&UE^pipJJ7Hl_boMlrcCR9eDALr)Ww;Kd8}y?;V{4z{
ziCDoEvVS$sC4mkPR)=UyfLlLN*-LFX4U<MUTdbKIRbit<xBG~~?3Wu6qKT>xp$1%~
z6qaN1ZC&Z9QU}_@9}N_+K)+eQ6WV)n{HRwGq?jIp%fu@j!kM|(gZ_G-{YNpHptiPm
zLLvsy$3H!zv87{Jn)bq9aC;`qa8pj%&k7KbEYp$(y<U4&lsR5-f^Z`|GR2n{yebT<
zN?Loni(<=L6rgF0U&$e893j<^OtfT~;MYEi6@{<qqc2MrnP#h9ns5HWQponkK*AvT
zgY1bjtXj_V<wMX+r8E;nYse*FQSb5HUYgXBs+Vt{5bUbXu|B+zT+J1(WyhU;??U<=
z#9I<M+WaGuc(j9==HQBsmV?qwC9oLVi7PJcl{eVY?1t6TkvTK4G6Jvnk?$#N&3^xT
z<~tn5r}Z0ZnMFLGRPtzP`!jz0*fzHOgqLIass%$>;o-u{Yt;yXH3#(+ypp-8?bgGQ
zkLuBmLE-k|MYaz12i?G8pVOBqwZEq!am*g?5TXp5{>o~GQME=HhQnwO6>n*v=RVl;
zLFRcKQNvNFcc6@5Qf-h_oMrGG!R<^ZK87)ZIng)kRn=lTHf<Y=aR1<~siIo;;;kFD
zhVlFyJq))C8ah7d)Obu+GHH7HO!MGqP|;+zih|7A6{D)nx1Id5GwM1_WBwzpUY63?
zFiSBz$@<irFU*3s`wc5$SLZ21ZpIgUuSfQ4>ATk_pQg0BCZ1=zni<*-uf3CXcJkK<
zt&w>{(LuOyFCF{l40BOzhi2v&qljuhLqREU{*xpVw>xzcINkqR+V|D8%DIs6+vni5
z@<$-DT}Sm?(9Ju+RLIM0%*Prap3MbrTW4NjJ(namOW7wh)^1!S&0bji4+0-OQM`D7
zXslb9`A+v0GjI9w1KsJEgKtO#l^g+?{T?_xFj){NUkUGZRabX0=W^lEf2(rTkh7S+
zlS1Gq6?g?pQLVAXnDOLkOe~?m+n9H3FEuqN+puDMZVc;d4UtLKq0_?JHJIr;sZB6`
z__%|D;QlsJdbDmkP;BQ{M2IGB=v)=tGOI)z6LV<)R)Jst#~|nZ7cZ18jpQq+>{_*O
zJB$l+LNB%3MkD(?s)u^1DvTzz$I8lE?Y>0LYkyi^LO<QoyqD{^_Thu5=&qB4gokCJ
zu2szU@2X$=XW3M&c*c`PrR*Co>|0)2ebr_Ttnj+R^n7N1&$&S1twH>ca%S~egL}K<
z1fLz}i^VX^>INRsQ-<&L+*unzdqKJ0F2sa3F#ai1Mb59i=dz!%qX!vJZlx=965GZ@
zTKKT%%}`ekO@)`|*LOvD<FqgA?*?nRGq?_`jLQ5Va*WzuLn}R+YW*g;Rkv>vr0{+l
zBCN`IP?5z!k1F^YGly<E9aO5II2fNf+w;zhmml#AWU%4>QBW76qZ{j1&nDkQiqu?7
zr6$J0cqdogM%hJcv}0H!Fy?^hp5tTO>oCwf&-b`mO&Ks{#mz|L&q&}GG&1fZIfZ#0
z-(cQivEIk)+#)DDD*TQW2g%Go52djMLzR7sB9Of}?fGt>P_wL*1@c4g>yaT-&A@)J
zKMo={nB|E~`HA!zj9PK?)`^?u5l5H1{4qA4=oTV108T7|N7?5w_|##BQU=ex-Ec3m
zM9JlZqEn^GyLPSx$(a6L+J&QQPfc%jZLc<SSOYO-m<9nsuZ1n!3dKZV#;$$UXB~9z
zo*sK=UNJv=u(V%RbeuDbnZW03v%1E|{UelQB^*H|1VOL7?CJu|q4jj5)2L(|1G0Mu
z&rUs`EK=l!9?#wlu<7mi(z(uaw->>O`Z!rrjbl`Zw!WBisVKom-+~vELYb)mbE}Nk
zT8|@8CPT!%VP{BPdNgiIq^IrO-a+;T(Hv#aNS9)Z(L@Hd<*E~S)EtYsq!0F&)FgZ-
zZ(l4GV&FMNj@-S4bKXbOxlkM^f#ue}PXD@X;bpbmdvm4c@x;?vZhN~WtXU;|-E>nq
z#-Fp43&aa|cS@kLA+l0#?~;h$@TKZSqTO_c*Lg*g6du3*mPj8Q)EJA035K6X>jgm6
z+S-*Wi7mUF1|8J=W{jwFGuFH{H+6sdlan}FCW6UO4TO>B_c3^(y!Rc(9c6>mLwL`C
z`}5riR)SM^KYmd%J*pe)<L8MVn0NOT0z*LG6AMEv%y(QqfKb-gZLbq!nrFuH90e(j
z$Q;ng$Kt*Yty-BLV0dX3$KDaU;jOkZLs4H`OZ36^>2YZ?CjIiv@E+M(e!T9qUw;!U
zkdcmtfgXz_>yzpL3<m$XxscK4zWhuxn|Y9m;d?9+*tapoGj6#5u9-hi$K+);&1(_;
zH2$YQqcYL#We2$&J2E`H$z$s^?f9R5V_??czX5?3^84~!8)o{37GhlLSnaq7Paifq
zk90h>a&uB!XYN_}G)sV`VN73k#Yu>9=9|PlGKk(_fq1yp@9Otaiupiv%CmW9v+&_h
z#!GU{hzGhm>7AhE%DGWwH~Q1@#<eirBzI*6UK)B3s+r!aaLw~ECtoi~nXf4dehP9T
z(RQSYo_yKl8FMQO31pXv*dI(j<?}^F-=SkNWgMmI^AKa#ANOv%0NryEJmFr*4uuLe
zpbXebjW#SzhI^3NEYxkdSSfQ+fqm!mH<a^L+0mgn-+?2{#8OjQFxFMZW&ZB9BKpJR
zeDx<-%X9TX0yw_Az1^&J&{?w4LPq#{PI5AGi7i?0&r+0_qN-CK2=(x{d4_6q$|6mT
zbVR0A^}~E{A#Y8(SYY!bFyP~%8g(<~FC(}Q7r!2H9feq121rxS*oLpjpUjj5bReYf
z686S=OTGl9yj-H!SAup8JenLN$B@BvG%CV(=nX2lX?Yu&0ZxxZIT^{6W!nk-5pA^o
zv-F^vsd^(#9{K@ZZy}T+r!M_Y#K~A)<lP>#Jzhijj}LR}HhAZ<2qL9XB!ioJ->UCa
z-Z8+{;abV!F7D4lmuHNOsL`2phPwQSQ>43)WIs>@ZLh;8_?iKwneqtpwK#=AQDZ??
zeP?)XSN0=z;nAld6I*KbETt*LOtg!+ieXAW<7!dP3d&C-`|!=MyiEskC81I6mA-xu
z57HkC;08}mFBV}`%7y$zA|y;1RP{J+-+YtQcVvV}3T67A<O9wXaLY3j&(vK!vQRHs
zS^VyBfby>1(f&X#T8V8#-CCxp1)*umYt0FJ!}8+%WY?~TTW8g3AlL@8ab!ZLIJk~q
zQYP;YwV2Ww7~%%0OG6|}&GckX#y>Or^u`e_F1?J@EmCkRvKsEkI4Us2Y{bBCA5M^2
z@H*jdpPuHU<&z={R_nzqJx5ph@i~H4UUx95n)}7Y1A6eZml4S`)wNo~{Dvjx)6_ce
zp$A7u^!cOAv>$V>Mc%WtZi~lh2`y6G4=iJ-t`5sQ<XCU%jpQ^%=QtxW8@~?u*m-}{
z1kC)*Vmx41(DlC0{Fd)(qU!Ui0{Y1$<=}o+qyn<t^tVVYV(H@QBm1(PTLn!5<O^qA
z^ry^c*9UlCxS!R(o6fArWzT*KF|M>VMjOiZ?@P+di@l~+mxkt11}dY>*^apnCc1X)
zK$V3FuRpwZ9~hp!OJnXySE5uOIuyY{`-JztX!GR`RFbbOdrmD--qXP0rPJf<<cAR%
z0$5B389Yrz=4ppNsFngYZn9s_pX&Hi%Sy&E8ro!lo#&rpGE#24KgOLFbMEZy8JG}&
zk&RAgXKFq{1%3CCY!!Stsz0D3GJwAC-h6VR;oH(UpQ6NewkpWUmSTXN9DknK?&n}J
z!)K+s))Te(v}u}XL?*UlScJ+2J}I00bEKIUGHXZAbvE0p(@@7oWlb4egD+K36cbV`
z#?I<D++k(X*ZuGgo>Th>YH5Ml*l9*>r?gyhfSpbVAI@s#^*GPo*AHeB(8Z=#Ma;t7
z$m(<A%<h|c)HEmOh3F5VcdU%4N!)AN>lp<fXG;>%#SL7l${*NE26-fI4F}q{s0jIs
zPTY&md-0*Kgt;C1e0r+x(tsRIY|`M0tfCL4EhBVAx~eEE-f&}%^v#@Y=i@C=p>=}!
zdKTNeRv)@oA3iF8zNs!HGvWwZGsKCKq;3m)bW+qh$m(jD89)v2aV|xH;i&n^{$Z6=
z$fVJDCCa<farCqTl+^UM;SZ;hN7vpliR22Wpc?iGt}blcx$(&%;1a!O)`|Y*ra(PX
zxKh4`>usP7n`<jklH&364t^0;uUJg^Cp`~yAn(Sr^t||aQ<vU1bj&R3eX$f{*eM&Y
zEio#P!#IZ~g_aPh51sWBYuc8iU@?!1#6~3Yaprv*WMuw%r3TUyNyq5X_`rL0VsfH$
zH_e{%N+vMNeEC&nOG5+skf}YL^x)n0ky7J8J7z?2TXDd#dBaI)o4+%s$su{d(CKyY
zLhJKj-n(8~*tvs(VS_DC!$^$reBio8-p9s0V=ROJ)ouI_vJnS+H={L4`Syg}=KB9@
z)JX@j`;BSF+j=c=pJ&7ig|{eT;<oi-dUccg4_7H;^$|ujY9usy{ST|)We3VjMj8`R
zfr==gxF_TnmB6?~H71M|IKPFcX4s=!yKey?(*36V=uhiybqMgYTymNRz_`EQtnJ|~
zW?D9Sk^CF&0UWMow)d8>P2#<H`@0ob0k$@P0o&amHvgyKhKcYN!F=iavrc<f<Q0vK
zGGN*VHC*F=Ng|VK@h!lKODF%A`en4u0?@Kqh@azsKhb8QLbi<qV2vp-t+Qh1ACmwI
zSjz!qg?)=1HvNCN9se!u@n0bNud9Wcx92S&LgHFLsQuzU|Cu1;4KN=PZ*$<}pK?4V
zlhs>Bc8O$ia%<&RL<@AcQz!xTHluJ`v%G(n9*W{jwfisu&hvlNxh*xq-K66KO76;(
zk!yh8j^8Q?z|vBiO~#t&ziuz`9<2=lFw@RszQ{kVstZPFY<R#!SP&0Dgn~PPK&@BC
z6ebo>2F4^XNv5cau|^#)AxIR8w<=bM4s`jPE_?_0uoK<5<&4AWt+(H(jKh#M;(c-?
z%Dy3&=CHmJ`HM+?^l{3vf8P3`S)lfx->UxwY5$hNiA&tVV<x$h!2fCJ<4dyekXaQ8
zun`VYRMG!J_&;)G1lV${(QX3tZ|M~F3;@1%*x%^<&+27QkZTf9h`SYls4-&c`=^X=
zC=>|z{!Mw9(3fAZ65l`C<2MVq9o?1&gx}Q2oVoFT;ZM_uln4AF1jMfuqfpZ9--^Uz
z0DYb~xu+ri33EPRn~di=Q<L9@UdB(fI{I6a{0m8c??{s<ab(P<2R1Qr|G1h-_0?^d
zh9;2%VYDglo%)N#7u^bf(&&qu`3Hhe5tRi{aW7N{G`I2no)XahUts*#KB_Lab{vei
z`c+tVtCBNA+thoYWUN+Ir(XT9+mNkpMX|g4Ze{%IpEgPWS~sJzY5%?(XiGwycz~^Q
zTd)UW9Qy}~{zc}0#fu|f+*Vo6U!?!9iu8iOM1|R;7KM*w7cW^5DFn~+Wv!5+;5K3-
z9Bck=XOqn`_v?+Pp{M!4fu2e{sZ}_dfzmR4D40ezHvGemgrD)Q>oNh`+&+f(cB+4{
z@m+5(W=@Uzct*={)`%T&cv~CE6k>hFdv$tg8qu+f@Fn50u(&Wl=)r!@eI{s0JrT1u
zxDhn(_jqu$9?$Q%*K)z~qWzNOM+MmkW*ZE43p0b$QpuMZIWd+`(v3RCsqw|HrVtRv
zCmB`zd~B3HbNKwdTDjGsb6eylYh8mcRzF33JhAoS&5uG1XW59bC0*W)SE2N;k2%lM
z%3{&mXwmheI23F;elB#me{FJkG<t_Earf?d&6|ud2S+DO*qEm<TBA8`S5<<0W_CoN
zUhXI+P+*qFuH7nf$2||XYkwRlFpEFxZ@5_M=r4y{zSR-T6*JnJ>n&D<@erC{9<Gm^
zX3x{++ScSh2pY}8SX#jB*qaSeY3u4A)ik#ua<j5hg>KcC8d9Q-u_YVdZ)9>`$_XD@
zJ90rpsqC%9@TgU)Nxj>e|73D*OKS!E7=f2FV#8;oOR`UIb7k8X{#Em`^y2Q_P2v0C
z(i!g`JVn{<iFk(VrV~F)o>IPh0^Uhe^PSCQFMM&R5VE^|a8PbBaBSdM6|Yv3LOn-u
zLF;yOM!^cEY7-)IOKy02+)p)8w#StQU9n0LAo@Vi(fF~qN>Ht(m{Yp-f{4o1`~g(g
z`QA?R94i>yh3kcuHyDWM9e*i(25KQa+Z+4|g0o&$tr;s)%}H+MhQtsq;BI=8h14z=
z@RPi_DlsL!GQg}>EW*cg69IuhyR8MVVdxKQHiH{{qn&Z8fp9!~X9sC@d6si!9d9br
z)kjZ-AKD4$Y!R7bHoK5={XC!^HlG>)*lNZ(=f*Z78SaybU)$#A$g+IK3H{<d7{3T}
z^pdMF%mxcqKetx@pldAV@re~W>qTss%h47bx#7}SdwYvYwA)Z8v>d0B-u}J7%7lxw
zuWiew(~vAm(D9T|Jz9gnla^}Lug_1^eYfr%$K4$~W8a`M(#maVsjn~g67-{zq62_R
zip@C>;`>GMprWjAi6JCkxc9;kL3LDCV<JFV*r7`mmMGMj{!<oVUvHH#kKHxibEd9m
zA0QOg(@+Xq+kxF<Cn-||oQp*enH4%0NZxDp`gmM_Shk0VksT;0JH>zgyi-!RW?K-M
zA5pifJtq_D39SGV8E6<OfF-kl1Q43m>_PG+Ybh!vDF8STKqA71i%U!SE2&Stl(uft
zI#x$tvx{YC=PZX9J3V6IP}{oL!BnAT7eT$A+pZ%>_AUkApcfEPru%=!RL+#2B-C3`
zy%03*2dd6q165}!w^e79w!J|oM4!oDUY?MTLX;%oKMnpVJY#vIUG2LR`Ty6QEm;)4
zk|F|Z+;X`$GEw!4<QeDtX$0b8v#T#j%4=Z}+CSVfi0blA)?G7S9b0IeqR&X`VB~dN
zlp>a`-T1I{f8o;CMObZ-`2pg!ilJmIVH;vo_Psp)y)3i_Q18X`v4hU;GONXSfzg0v
zQd+5gEyZKoua6iQu*~A32FiwtW9S5&!+({PJ+X;wetTreOeMcdPL!N&4rbcGtVb+{
zoV7}p8q8_)Z2ioH9#sUX`p$o>qm!MgyLg%#wie<xin6;Hl%`X+Zr3<$p_;?Sfa|71
z))V%nntX+E(08axn<hM^ktN0{>Y*lf+l7jAdt8u(L0G61;`{Y_u+Pl*-IKi1!dekw
z4`Zc%{cano9kDSoBClEB&5kg{m8bm^mW`)TCnNurmzk#S<hkijXebHsi+@WpD}T8n
z&1z-4$GiG{O?7kDi9(X`_}hW0`%BoMd(^!I1L3gprO(=6l+^9s;P$}~CtU|toZ2_^
z@-CV0bg5GWTyY0QL~&TXE-_2PwvY#{v)tcL`z{$a=7B8vEx&f?v<UN9>>a+7cp0t$
zk?VQ0d-RrbF5toNShKJJ*GkTS&OS^mmpz>N>`seb6)INnN&*W|044m0%1(41D`b50
z$r0p=x=S_Z8J0&OS~Gx11AR+?(?Pi0bxJ{pw?s^jKi@a8H^^?FWvt-;wRP5UQFLz`
zr$b8Gl?IWLkd{WI1*JQro29!%0qI7%q`SKXrMtV7UP8LwS(E4U{{G}}X6DR&&g{<p
z-RruK>cg-q^LG#~NUz$b?sLm1f4%OF8xw_^djdMi=OFo!S$M<iCTx3ZbbbNVfGl3j
zm1NK4rS)$alJNRDV*GOty;AFfsp8m5+#eh@X=#OrN17!mr2;xNvzrtvfKT(QdbBdc
zLHuQ1?v46+m|Hq_PNWbn>|rpIIq@x8v1)I#!6%cN``tK#$ySoR<CMh?7n0A>n{RCy
zij%NfqC`2ACdd0xzYo59GalGfo36QXyE}P}(rgRQVHP*8D0s9LoS8`)_4uT1lP!I!
zaXnX^TK3t~K9|e4iF$Yi!8iH%>{sNZkd|qpoPqaxqoMj{uTotKpD}5Nwk{$M<Q<*<
z(A7ud<=Gg=o>L%fFBJxj$9!{Rppn4YkWFbo^$;KEsP>Z8J9+0B?oKypyLEWMwISe0
zn*C%tFrJE3w1Nj;W*%ezwB5MmM^_Su*K&K6ghF#H4bRJuzW$5JVcmk)p(WZ|LEktS
z+WR|Eb41$9cEUtZ!ajU?<#prVyDXPWq$*Z{hXDsaRPHM3UgqLdEYS6c`g^@co7U4n
z*{_YR(dIsS1Em+<HFC2&xv%+Q&@kQKg+wf_TvDY{3e{cFj>c>mcpTM#Bnh%V!m2C?
zAv3lXerqdv_#>iM^?VnT-9)ZPVpg}GC`#9<r?E}7V#nG-+hHgnQGLTQYH4D6y3K+Y
zv<YG{Flb>hR4)7gLfu<XD)xTFkXe%|v#7hJ00uvjiaX)#=Y94pEtu7d`pl2+RS@pV
zfe+5kV}?xTRL`pJu};o@^EC1Aep6Lj7#t3kI#?wwbBOYjijuy#p;D#1h6c<5U&N2N
z5?!YNIU}*46UOb86RfQlWW?bT8x-Z8k1v(5W#aPON`LAG0wM<9mg!+{%v7kSlCNi0
z&rB~V3eOpiUPv;Q`udwkl$~9-u$`T1vgFf~#+8WY>3r*5IJRGJ8Y7=PtS~k+sn_UG
z&s8X9zqthCg?jvWxZqXE=E`0ivb*ZH6p6DFciitP=-_DY-KP^AP%h<@0jMhO=?>O=
z4Ua>-vVU0ka)EdCYI(d4UhHcXjZP3sDT?LoSu1Gl`b7m%B~+ILjfxlN9-Z8fx9uS>
z^7+RE-F|+xc=HBAyj6q_JZAG3b0zBRmTDwf(J;&#wT?QxICC<tIn0rf3I_w9QzO#d
z$@7v`NN*Hm?*j-FszK|6<#(I&uQ2YoPm-KFV16LXx8Rjov-Q-frz9N9L|@Rqxemed
z!rcrI_mg#0mT;{m=M{t~v7aV^c1~WD+tQu%Zx;0N>ETAo<s}LB#P(g?FVV_EmpXG@
znp+3=KYPHdm>$iXFm_MTxM@y{yoP-&Pf-ljRRkFS6T?cU%~*KV%3%R3LzE|*LD?Mi
z2ClVrxj-i+G4L%vQ82Dbdz#9EAgTGd5M!K<IqmB92P(pT=Hr6*4_(gwr$Ft&J!JLC
z!ori2ZX*nA`(vIpG%qv180cq!xuLf5aMHPga^~RCZmIp^<(b(vk%auhr#JwUbe0E-
z5hzfRZcW^e$&cyU|Ik!+u;HKmqt%xqFi*6zWjgHfb)bI(S66-V>cN#X3CnfnVtBNP
z=c3X<P5F}g>n3#&U+xYBv**JSM59Y@cB1b``|V5~5s3FhobM0}UwCQB{%PRHV9;s<
zteHaK8dTM1GTI18%<_B%m7CK;*Lni>hKy$kx=)HMsW=$o#AcE6Gwph3rYa23Z?qHQ
zwf82Gyl&hu#b5dBcK*0s_J4)+rq7OKzm1Cs8#mR!a-O#Igqvq$|AZ|Wth;AoakeIk
zzBPlc|GluYyZ6n;Od)4}EQ8MhS8rD6r&tFD{3+l%qEJEe<|N3!#Ti3mf$Z&fUXD(p
zpb1Lav-+8_vY^RKrwZ3C>mQhq1M&rpX2cIY-BIc${#YV}#V;0-x85wem1JmSsykb+
zD;Fr0)_I=-DzgV;XN(1ijDdb6i(aI@>MdcgGBhilp=57PKI??%Yt}OcT58O4Hs6>q
z#`fLJk39j6@2cNguDwLQ;j_%oT>ns#ZT)%WoVUN;`CJb{3{%Z}Z#R2s{rfjPh>mez
zPZcMw{UJS%{ROv5!mVYtw1FbrLTcl~c{kZF1yls9?TEXf3*F89HWvw|2wayYdr1&G
z9oX~zpkvjh%~GKDll|2WN9BWkwc;PgVevXIFV1EeP58k`DW2xoevJ+2ZeiMEh41ZO
z?se~84m{`EU$L(w6+mNlzo5F|OE|Z)V9jSZe>R%3I>S+SpWuUb6k*2jSCGj;SKI@>
zqn}!{+_6XN@Pay_MkRyo3aLyS3<?Y;SIco8;s+C9L@%3y1EgC&8g38SkHk4&Y_D_U
zK72!8;hYgbKcm^I@q+0;+AJ|BkueZ2C&C*lg=zS0S*oQ0a^};|U*7)(Izn=&VBX*2
zuv+4OV8L4kDwz5(|5@xmwd7i%nwmP~?|)L&AwL*5;Xm56KaD_=UP%j3q9C^zkMcX(
zs-Z?`#tqSP{EZ*LZm<(+-mw51Fmr*FTi?l^bz6IVmoO1j0R;0q<DY_>{$^*5Eq>uC
zyc(DqAhVu|23iwmv@D+d8+mIofKHkep7w56+_g2~L+|Hpa_eJgk~~xm;|BHVr8z^v
zM2TRHEbzx~LiYMAoHA~WQt|m87O+oXD_H0H_x}I_fC|TQcvI$qEV@wH`<FM+2M($h
zYE9E5`8O0HVHCVM9^eW|)RT7{fV%I2EW8MuQz{7<tNwWaYm)(u*DPvT(%+j_ZGqAF
z7zVVugH`Vye+e9K=|xtKe3yYa0wJHobmD3FQ|8YJ_GIz5L(Itf?}U3pNmo^a)&Qo)
zAC(q>3rv1$$*wjo0Pe%hpFs(z#$+*%-~pZ3W}GG<5CgkN@BnQYsbPS2%x5+2H6S%p
zbUq<2WWv`^OyIM70DvNoO9&hk0=3otKL`Y9kf8cS^BJP*d4lSce>a!~v=+=UTHyT*
z+Eg)&1~3z<iO{~YR8TSFZ;X>B<O9qq<7?Som9D#5G*O^7VvR{s9sbYh`KsYv2VF4t
zv;f+Zj%x@1XY~Mc+exQO1Z!<`&t~>c<6TNKl?ZeB%Wvoe*auGs`fCyHT>jwR-0%cw
ze*v42;f~5`3XtV#Ys~6fFaxs7f7&rT;3>NYcl&qnz#89avIZ#MHHz--znSQQu6%do
z3b(t{I0Jb93i_{mwEr0Gz%_81vUb3XbJR#rQ~X<oK082Lg*iCk4o3xKm;lO|6m!H&
z{9V8C7ZRKR42_c)r`Q^I02~+#I35BU7NmY>9lTDf1wJ<j;`nNQh2n&^6{;%xj~4A$
z{CqNSf%R@b5o`V7uA=nbOCa<<a<-yBd%Yfl(}ZfxeBRy%I^Pe}yrX~g9=`{CsTL?~
zc)Bc`zTCbHU^To^S@=S9xk&7nLuz88owoe!K=rr}<|SmJf2{Y**0}GQB{4gS;IY@e
z-F(HTF{TcB7QK$#f;$chGc&g?RRva|vd#_TB2)bPqQoSuICi9)AtQUFX7RCPS2w)=
z52b4o<U1X_5*;SFHgMo3cZJ{gUoJcCyj6==Hr6Z=qtHEujn=ZePwgdWw3ThAir!N^
z7Z!+iE3|p+pDrx}HMO+UaU*#OUL)V)i!U`T8x$9B;mE%>+taR1X-p}283elMwE=6p
z<1k6fwwWHgC=ebCM}W0$aR$&{wYp53ZbZ9gKgW>$giJ%Zd>vIMzcl~`lsn<&RK%!k
zgOtmw3KBOQ2!5aKG3X5(=+13fnL@AzVluqKo+<@ivtd%OiD2`b^5{8sB^*}qM1VO+
zgza$m7c04m<FUhr`028XyR=?*L~I^R@p2N-e0xOBKdnn&QH@%F<?LT${$XnE$=r^&
zf~!N@f%(b7H;bLqugXPuVFs&DG>J(LWc^RhbT1w4wJK3sNO?m)^zgCYl)OtMT3Dz<
zR5E&{ppavTHb&~k{fy!%BR)x-XV65@_a%9I_QzGgFWaW)ZE`Llnr@{6vRE6RvZd!W
zKGtu$tx(P}>wJkBkO5~&<Gz?Euz(89j*cHhpHZP;@0zWem0V&kl%?bqWL1-hTO`}o
z&b3g>OS!dq4T2Qn`(Mpvz=x*W>@T<?Jx$JE?ZU;le<V?)$<b7kBy0vM(L7i08`28#
zAH4{Y*wseu9vpjN2I&)q6LCdK;?#O>78fW1(nQ`2k!n?opUm(ndxg0^za&r=t2Uxy
z@7r8W6P}O29LiJMB#&=ZqU1ZU2%<}D4-PUroTeT^#LtQ5l4goYUREAd+O_W6<9?JR
z@gkmrTJBq?{JvGr^<-b?c=vwMs<&T>TSiw!acv_fh;A5^|78;r^*TF-Z7*>Hb}$gL
zww7M9zorYhiG#CeDtpFIDqUfBOVx`V1!>&@sLb?TxE~@eVUPYcGsAF#Nj_OVYp71l
zp%8-y)%P&fentk>IchYTt<XH3H7NOeg&6%9dWgVTT|LDU0VWklJ1#DZ2P9QO_LaDz
zEzU$L|NAY^o4PGi#tw?7h^EB@bq!hEUpK5wwl7$?dDodHO+p9T&}xSZAIf|5i=QT!
ze4(80N42TyZCl!U_Z2z6mGKeI>m+umbjMzOh~Z}eRn*O!y)E|v<jKr*iBm_>gc|7q
zN|^!P8yAec-5C9}7e@E>cRn%6oTu50b-ZR}6Ksl%EBk7d!d6TV8`Qq^x(lC&3z@ry
z2{zdmlZOzQd*a}^nCgT#+Rl=Wltkb|FK%RRDiP2@=sZaf&h^!D+SHWr={Qq14QNSe
zUM|`3r%p{aL}-OMr=wfie}pk<X{}iNeepnmKyooRXso{TI^6D3nP{J9!~U$)*!ZPt
zgXnuDBN@w*HAoQ6UO`wlk&{qrQ>&tg8<6G=cWAMAjv94#z$720{$Qo2LoEnRZJlfO
z7@{SIVRJiaRq?u|5>1dLl^ysvRS*BxFSNa$2026gc#cXLZm8Uy{05_mJ}N=>qS8Kk
zf#{uCZ%ul8R}&a(pz&}SFYcW^_5Bk;S5hUfIln;jQ-DyQui%iPiLXEUkMd0Gr}C^W
zfAkO#A%ySkpyWJQ7tv;APe^KCSq={mj6}ms8@sv&FFJLODR^kI&V^};XeRb>Eh@bf
zO-LT{e=I~8hcr1YzI?Hc&An3>JFP;UD{ZZaBg-%-?8J{fV9rEdB~#bO%IorS-VQ!g
z#^Y$m@}d*r>xOm8`-lC()A-0G1o1Qjn-QBsZqLY##Gf!V5d|0MyrZO`mCNKG+)_Sg
zV&bl0M?GlU<ZhuvZFWdnTFDfbe}SZVRnaa1REHAhBB$e{GJnI6&|{W|&mon-S}$V0
z^UMo$i@4}c71@`#xvGt&zcnFvKQ+>pP5kmzNsVbp3zJs+vUwf9C%+>)hg5WHQnSYx
zuJ^S{xj<hf{n5lpi1V9kDSOomMo(Unccvs{!lKq>6?+rRN=WcqTwRS`r}69NHs92P
zcu=esAAENc44BF{lyjWK-oTAq3Xg`Pq5dj;c-nO?P-K&7Wr%R)fX+iLG?C%^qdQF#
z(^f*#U*Dbe`31YMs=w<#<~^UIDw7R`5nXT(aURSk&hX{6H0~^;0h4_>sL%`?AT9h^
z0ptF$giI|1RedPMQ#0!(u2f+QjrGW8*77_flPh69d&$kA&TPufI(3OXEyPg&_Vfmv
zoD;sH6u}>FK7iG12v{rQ<Oa0*YyADu*B_Cu>QNGJeIuQgZAl5PY@u2n8yO^}9TUj@
zl1+8)es7M5RxT+riZm|tM*ur_oZa(tF8HPK30!Oj%7_TPWZ0CEHMsMm{Cxk+988+;
zG~`<^9$pa{Hv4DOz=js{7~JMK4O1`*xP>0S+%C$YQv-hS5`ZbnSN<Gq*-*i1EsNn%
zN;lxQ*gC*=a?nY%SsgrAov(<Ry4$n6yuFo=RIkrv`Mkm9sBC$S?#b@yqenWi<7V}E
zxFHH$?btYkLDo0(L1_ViqAb_lWN`=V^2)l;;}e$A&NZ%arqx{E_@07agYC1KUJ{TM
zpeX|d7*Mx5v^c`E9wzQU-cOnJtZNV&f2L~#2iEW=QR#C8r4O<Qy-oP~SSfsYFL<rI
zIiN%v$tr#LE7-9Qe`i}E2J0!cP60Vjr%2tCceMmQEVQI~fRaqH057Set9^H0=~E2Y
zf6cV&_St2YG*_;gsbvowsVobED`iu$AaOBm>PYvdRGJ$S9X|t=jfocZA{LWi5>m9g
z14W47r)v-R(9=ty94;(9^aE1~HAh6*WU1$n)k2&1g?ruC^(iv*GNgWZ@JZ3SlSi;v
z+_k)|M*>*fG4?NdI53h}j2(C<$MO&*_pNsVE@@oS%>-4F)FK0Fr8mJ~(PHL2!$<I#
zR&~m6@IlI;ea8}&pVq;%cXHh41Lhy+G6C;kNr+aaUz$SE*48e1By--Yj(X=34e>tr
zMt>!50x>GrvEmTdEa}y?jY+UkpUF$0E^X7+SXZiu&buqh4zHeENHH2=L{hBZ`Q<4U
zB?UHzR4i?9w(2fV2kr`XRAJ*tG=WrUL+vE)+08}^;0?`<)c5kT6}0xNz?J8pPm>;G
zfoIvUf6avWaoyCkYbi|y&WmO}nY&;SX&qj(Jqgf~8GhCP#j-eZQ^ALpNlF~qKmBF`
zQRAD#$3k_tK9S`!7+JSR;Jaz?W34#Jl@#;zh{o1|^h<@);8%W(j<E1;pbGC7(Z)g|
zNo&Ci3ci=ZLMxe5o5jV1h#Ke+5f5QhUt>AxP79XLCJFS>S2)7fM0JcJ(DBnp^WvU3
z=2V`%stBIxB75m=ERCh0Lvl^>Cj7Ed=2_3X!-dEr1mW)SJ{|Q8Sh@%h?I`8Zi!U|R
zxK~6xl;1QTYD#TIxOeDo6$n3zSG2a<AB{gOG;ODcUkKxbyePsl`WQL)<#KkIyz<<g
zG)1+vFPhmw`Pzv%YT`B&Td<_+@g$sOuRpJ2+J*6`jOo?4epNe46s&>x0wkC5t82Lh
z-lLFQ&v;ha_2p27Wo*P5By$b5oSyNQGF$3ZNLw-VzPp5j8I7#v4W-}pRl&}J%>uQP
zisIY2Ry`)gWnoqn%is?I!q2@0<vmyz3;73)7ryK~BtXnLd-Un-TeE?w<_*ChXADVB
z@Wus%7n!!LS%3m@FGnOobpb1nx`{lq1yIJ0-8j>q(?xz?`7~gDOi`vR>3r=VcO0Hd
zX2<VBLgyn8;Myqg+`ooB>)nOn{rM~&z51~sz)x86quvudgAE4=z{mygF~3lS%SpP(
z)biw??n$L6j)~IJh?mi^oSC1!li<n!R4F0{&fS7dX0^@h%l9%XZFm8iw%o<aG5Y3H
zsxI7tWplZ@tUfPF(#_#GniqX2ke&qUBnechh-7|5#ZON%04vp;klBRXG{W&ygJxf4
zhXeB^Nyh(*($^Rf`S@D#tqxsdvmkzo4<^{YqGt$aVwyfezg$B1vd->|>k)#+?I|B8
zx~uH9WH}d?)eHN`Lov(YhZYs`kOT*cmMS-kuM&+zwRByOso<$-ydU{$L>yOAy0#4i
zUvGGuEa4eujl>x(s^V~ll+~*=uJsZY%YslWm9W6}uj868bUn_JFyvZ>ln<BaG!?!X
z;wdtYZHSC{!~n1K;!BZ&a*n$#0j8RA7>-#D=~_hX+iOY)o;7GG#?P^bvttd+c{;gD
z3keJUumCg!yfFErleXJ9eF+nJQqwGcj`{CbJaH$wYU3T26WGVG?<)ylSrBTesD^M^
z+qW<JpVmIP_jWY4H(pTfThh6Dk9Bgj=3^QkQ!nwhviK4;u948r_WKFJ(J_;Ko;h6C
zwr`;YBLc+dQV;gc;x9SmGg`=2PH9#SKiz*}6(IJ3<~q%8%rvBRjI3#-=6|Wlc=8?0
zuxvVxz2wWR-Ji5$eM;|%DmH885ZEXxlY2H>xw4q)?6K~bG`)4DQNZ=)+~;=8)Xn8=
z^Q&C2cFV%pJgP=@#z64k!PgAP{#yC^+0hEMLcB7KpY;t!5#gX{lZ(#MfsWT}F{hYe
zzN`w?d=0}B_Tw6t3c*_&wb@g5|Efa&AP@Cb%@$0Q%`2G5o-?|K@m`xLRw#QvU<L%n
zVO8omMdUXN%ljTabXR<P9Z+3mb6&@Z;#vM|&G>6@6MHQ;;8-E4+EG94k~nf?BQQNx
zs|zNZE#oO}86(CXT=4(wYIwL~ZgH8vb=~AbU`D5KAmQ-|CsK^#`C)jygtg+xSVLtf
zemHyf(@5lTu^t7EaJhjFs3QP)jj6#_T7KPjRYjgzzlYoJm8tTL1a7`cD*Z${XEc3|
z2o{{TQ8-}i1wM3m5l<*Zx!+`q;#|kBSx{@hJh5iqeVIIDP)_r(dDG`2lkau@hp4>N
z&^=ehZHQmCLgQ<vkGz`Fs@AHeO^j?dwr}C8X<DHwr=N+iE<ccL7a8l6Qvaq8MX05M
zc%}CMP@r5!G=*{}t#5~J!k}8NS@MqzL6HX3sY$V7`@8Ov4<JL)0{9genyrU2O#ay#
z0+5C1QbR9gAg;QA{&x!qU=+2uz_pw*I_v+8#{w0KH_!kEp^nmN_Ip^+aa7Z#9YgDT
z-qU~<W%@(Kbb+&?1xGSKB_6u{a27<+qk+mqt>!J4Dg3{Sf&sl9DRc?;XGFuMfBM#b
zpBB)NwVJCmBtm5@Pw;d(ex7zH9DpYnyDuHz|K&k=h2ESKUEV50mk~|B!5?%0wLl@V
z1&vk~z%Y2HO4Gy>0BR(hV$S}l$K=h3T3VzG^&v_*p(p;^Y=ibS3v}>Z5$5T4a9f&C
z1QaRBTUq^e0%pPhb!8QSzClt6v;QPEc(epS>^j>ALjHqFmKK2EFC>!1{T9>Ug}~GR
zUeCEIV6Y9@t8edy^w(w`k?WQQ|J=JmKE%MK?7YFTKkvViyj1{tvtMyaxtB-|K3fAQ
z?yPc94<Kz<Qy!cEeY@GY!iR#n>Pt)jw;3X9LUG$<+6$n^qm~U+K!?R3!T^-<T7oRg
z0L(5Nf8?8>p-pSzt(iqdbkRS_58hBS5cyq*{s|Psw(cURLh+~2C@>n1Cbv7%G{EBu
zudV(EME%r6Apz@UW=U2*icZL91%GMcC(UYwIyGk|ZuHFm!L2Hksh7M!YhSUR$lq2#
zGAIVfv*vScK>u<4;#B}K(_4U@<NJf$PAFQn2>?mr!b-*W*gMAu0&+KNY;rr?yDI^Y
z)&!U!M8=-uKVt<$;530+&i~!H<mYOhpn;;W6I2a@f4mL=RI^ZM%!tkKd%YKGdG7*R
zu|t4yC8lEb{v~;UvJP6ft{?Kem-n~F^=DW}p<!9oHco{Ob*cu&4GO2BR!!d7<(=OS
zN?>k*tyhp5Yi3sa{yi^vL(ttpWOl?H-vW~%w2TVwhb|lo0AZFCL4>PQe=d%n10dJ&
zfxG8?G>?RKCm^)1EuafFB!vi=V0OAz*`Fcs9*0uidad?9#&X~UvxKGDq(EzSQ(N`#
z+k~DLuhttdxD8XZ>Qp#PokU>rW^dUnztSompy`C!UKm+DY}OP_=nX(|Y_(=<D!YQ$
zDg3w+q~D+^<H2Xw3Tkm*$&4*Z*z*k^4b5gPl6|M;(B2L*JXm0eIhg+ri_*N5;mE;=
zKUF`2HQI%=(xk$$`lT)_;=Xm2f8ETtx6UZ2HeHpb_$>A&4(=yvE=hu^4(?wsxU5e)
z-l4{@7)p^(6dlDqVUR?e3=T$zC%9S*68A?+C}O9AKRe_V<U5f^M1P<L)I)On*mK0d
zrZh73naX!&xmOFKCo`q_gzpEcp9hbSK7V7yULg-J3DH~Q_^d(YCP!n2VWC}h4ETfj
ziJJYsf@Is{Y<<XO*;eai?&2q@V%8#~v3woUpvh)GWB=;GiXg+Di<L>iuJp@QnZqZO
z>PEXf>!k+g3=g<#L)0coJwH(x4SJ9+GI?U_xO3d^S65_XsL2Kugdl|8<cr6<BH2GM
z7K&;Eao0=ve>SnJ_m#HaFEB{S8Ltyman6wU#p64c#j9_;@5|rfOfDc5_Jdvb3l4Lo
z8;>?)!7Ptt@?^emnGVCZII)<756=2q)a+KEAV@QckZmMpULFtkGsC4SEaugsSIikN
z;uQ-uv`1<`8l`?8zz`}@N0lmd!z@x4)xY?0C?U`HsUwl|e0fP2E11knQZjD1=@O%R
zLNT({;cAR^|3J!L)|h2`Hdc$2+hG8t)9i&2C8qUdL`k65abCD6N+(`j*cZ#w(0zY1
z=xC^+@AXR$8z%K*XPEv5&Jo>LjN9_5W|;>P=gZlZwhNBLQ!ef0?>XcPJWjiuUEG<I
z1PGD}#6=c%LSsp`R@6&R7PxF3PK?AZi!oSsLaewQDA$Z+_i~;>PTJzr3hL1IsJ}?X
z?GELUYJ-Lmb7bRBC#R>eJN%rwcGMCNT72xv3`emW^T#SitXj?B7sg(s8HDs<F@;4U
z)t=vb^R4lv))^X@nSzet)nQeFJdOjc4x8w1ic_Aw^BG--G7C9BKG>eKwIvDXoIVTR
z%y>fXF~?<GWTA-SJK#rLQbeaPbape+u-5!;Znt&}t39O3Z2}Br>J%FXwzM1g1C*wf
zLN&Ba)$$c=(!F;n{MN0bZ19X4UFqsoFNg*A(vx6dh`276v*L=|waOwc)L**tvuu2z
z{jrG?6pVgUAlz_Tw;C^=DOYX(&`eoUcu=-%>Lf0wC;V541>MV$2wx#|=&~$*UZ|)A
zU){TcALCNRI5`=pU)$OX_IDNZb_jA>oPNuxeK}Ic(s<e96o8_@l=y9<w^{J*{&H@X
zgpA~%T*myg^!F0|5p%(%uHz{_-t!IbSQNm3JrthH*IO0qvZ=?t0BV85UbZpPvU6~d
z4-H~Z;&V~zU%Wh3JDyf2iw;BGwou=-0&(vr!)KJh_{VOJ4+GWQ`>@JitUusA^(Vz3
zjY%8inbjF8GMk}-)gU}0zben<d8?7<d5_N>1MCQIpy;$pZ2jULx9*X<H9LevXDG2I
z|CpL)b9u|C8RBszAH!vyqq)oHHG&@#6S1U;SREf>To8qa<>X|C<#o&c&X4Cg+#9k~
z_ChU<=S}l(+TZnXyHD{C9#6R%?V7oy?!5Qo%}B!8d3Z_qnjYgjlMyMyc?@XV{J2ih
z#p?&rJV{lea>os$c;!q#@0Lo9vBqi|&XTD3N3YVwVJVB!Lp8%kY+D2#0-q3`+S(fU
z&ev~0PUUw2YPlWW5Hk{PgcW;`wN9p5dCR5()xwYcEDYM%azwE4<7cTJKgQPJBI{hE
zd-dGP<>S7U&J(q(obi($U@_v1qk|9NPTVuaH*83H7L8dbNL33(I=-+iEg6s@C)zh!
z9OKox80yZeEY#ZffyPNCVl6nv%~C!gwVNAXw1&eXD9R`uRb4D?Ci_Jj@Q2=RXFDDg
zvX&G5NcCr}FR<6{?{-IN*a{G=Im>V$Tt}y4la2~o2=os=?6E`}X<Pj=Z?h4e!<v!k
zvtfe#?)|e&`K(9Bj{a8jlq^nG&m=tZ%(3VM<giXHXe6wPkv@NZma8>b^0Fvx*k7_&
zOjmNqo{zT~%kyJB(lSNF!`;nfhk`G5miyatmQL08%?YD~4lGVWPRTkOL5bn_Q;$KK
ze2itGMOHJ;2r&iG?Z^r#-rCP#xephqw@p+@ivU~uY3egfS}!l8df9<i4|vv6>j=^a
zLZ1p=Sct7q_m;~Ku@1HEmJ{LQ$CA!_t3)QZ7Eh}CPM>ceihp_pXKs9+c7*oS+2{~s
z%p^8AX7p;zy~uXMo`>&fi(_YQDGXI4UvE;3EV|$$I#~<5Lfonz@&5ex^`YYfl(X2O
zlPvCJS$}M*x8rhiZNBDu9Y}(T#YqUDbs1$@^hZ;cqmRX!=F^o5R1pv!tp;{kAF+_2
z^t|&2v_bTlOFf@12vgI1{oTGjjR2lZwM;C?aq5TWb)7B^{+x{O;h_)C9CboY#tyBj
zHeJXlW27&>AJ&GAA6AuS$0A-}SouPqzQxp>syUgU%Wu28*+})No{a?X7as4EXJ0K<
zFsJyeX*5Ps7UnXyTdFnE)p>CVgTT3S^mY-f4&H|$7$}192)6|tb;+)U5BJit(Hf4q
zOQ&EjW8@b5W@g-8%8pU&`N3~h5AbCcsxm8qmSyC;LMYCn+2HcC(hDPriG40CqsAhZ
zHnuTme7{am)fu0zAGCesgAk{Xcw$5>%jT-`OBPYI?bVF-WE^+M<t{$b?jOAnsWR*S
z$bEoAz{K}Hg36a7v!283QHK4d;#b1+@>88XYh}H)9kqm%Sd9nI+oK7;^lNM1vk{Ar
zG~LqlG&DoR5PU=%M-{gFEF`(*%J+~1j(tv{w|>GL%xj@)))c4DxQ%FzpWW)ayPXCU
zIW5~<ax>eS%X}&p4EcbXdcx4xufAKK$XVhSB}_5Z0wI={A1Ph=;&q=S##<^zTHP?Q
zh;?b4_hESUXQtt{cq1Gb|J32O64oKdXjl)UtVH?s36Qg{E>8kFyMgk=Ql_syl0076
zK0~~4AwnxfPSWdasfU_#=(X4@-tQhH&m4U%z}za~I*T44Zj)!@xVlfe6=1lCkmhn}
zQd|2F5E%h4GsDFic<PP;!{EUqbmvo`b|8`nbWg!OV5gSQv#kQ#jWIf$;z04~@;sIY
z_EQyK6ttGc=(vuX7g}2zAx=sRraS54IjUFnZ5q2u!1g?X(kHsO>mvb?z!$1~VRwsT
z7>ECYFqW|j&GF5=GXLI}h<O^0X%%T+r3xGBXa#{!HP`ivBcc{Xq_Y|@a8yVGogJsI
zShE<-vEF=(USv5BAw$#Mt*!|?t9_(cs0e2W=RVdoS%{yesrKVDq9LAUe`z^#0lM@0
z!W>c<QRyWb^3_c`sh4M-cnl{}bfJ-<tLPZ9I1P!qASg^J^;~b-&GT&6j%>_2F2Htt
z^mVZjeUI|1wv_|w{ZaqsGyQm)dh`!+0)2tGHl3C6yXM#X<Cp7YMv`=Mx4P^JRlQf7
zyAju<wT{z>zza*;EVCk8R*<n~U|yDJ#WaWc)l*Y>(I?u(-kg>h2SXym*%(+v1i{I?
z*ZV6$9Hs6qbm%0m__DG{3Uw1S2^><-YcOq`m;1{fT#32ZTaox9RmFT&*>v_alq!3C
zTaRhsiy?<r%DP4rob(KZsO1vArT<bZ%A=}MA*^`{Hqq;f2v7#bGPS$nmAd(~oF=uE
zWwxDJZT5a_F+tHLIcE_#-{AV(^;j({L<y;p5`XHm_nyM&@WC!R-w!b)dd}WU_<9>b
zc(}wKoEce;MC#S|AnXl6I-Ibupyx#d@nlmY+Y_%IFJ&=z9IVaCZSeCvgjHf=o|KC3
z?CzqkhG2hCd5pAr{!~TowE2a?wxQx_$GLF?n^Jztx?z4{`UmYMtEHw>rsaOFlBJu=
z)qYpyj2Apzp-sVccCQL*_{Z{N)(w^A;Mp)STYKu_?2bRlj3V@<y5bA=p^M!vJT+QB
zkBL_r``TB#FuGqlNp637OQvmgj_G-A7A5BDcshUPJoViDw0ovO$44yo>Y{@~^>BTH
z&yDTsK#jZp);+~gy+4WHfxkJm;yQLdk<*5H;@Uz`1+h7y4irSV$9i;jRe`ZFbD-bI
zVnQm0eu;@(boQVOs8RAVn(bF=>qCjNWCWxTyFjinz93*2_A^WQ1q{l8wtl}i=a2r?
z(*ZJ~Kp@r8m{zc$fu?!pc)CCBUQ^ycE76ps1?8XQ4@gSq(eOlD-A;>EBk!cqc(vj{
z{&b4+wG)~E{Vi+r8k$E3i6qb7vE)2?{n^8~Rpay0+#OMq&@eRPSGTqb`431ygxX((
z9@OFdqaCVnn!pwsKuQSgpK!-KraKN?smS%T)aF0wC!jllwO(NA`)i8fM4U3aw+29u
z#GrSeJ2#*XG!<kubvOSVJ2YJk0q(zHdVGiW*Zq^%z}P`cq62!7H_R1be-CdBg(jH?
z12v7?cgj6mK<gRp?(tUtk_`o_d(Q%is|B?DkIWt?XTrbqu~i-jUaXXwcGz9PMxg}I
z6Mq+-6G~x#l1o!W&?rn$09i863A~2z9Rwr+*GalhAm37}{x?v-@N<EIDk1$u7qpJB
zoWG|39$=EQrf9RR`a62SX+-sUzgLxbzggam2*4N@%Dm93R7Noa(8}ZP=h6W07(z}0
zm_}Rnlqm4W)O|iQfO8PNaz_XH$sjL6<wz6Bt8LJFRVEhy>QxEJp@4~gUq~9tv*<fr
z|6aHC0%3|04d4^%-k<6JwgQw3sIxWccuE2Yj{X^xbiY8O?)<%C`*%+_TwSkS1t3Bm
zdrl|+V)=K<a_>Mo?^xg}W~SEV%)bu)wNYvsHW2lP(-Awr3$sJxBeVc_iwpyEd#gJ<
jIScGmiv;~TfrmNdU|>bMColxGz(|V9z9@dK`}Y3;4E|)x

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_geo_autofit_v3.png b/all_static/images/whats-new-in-v4/migration_geo_autofit_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_geo_autofit_v3.png
rename to all_static/images/whats-new-in-v4/migration_geo_autofit_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_geo_autofit_v4.png b/all_static/images/whats-new-in-v4/migration_geo_autofit_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_geo_autofit_v4.png
rename to all_static/images/whats-new-in-v4/migration_geo_autofit_v4.png
diff --git a/all_static/images/migrating-to-v4/migration_map_autofit_v3.png b/all_static/images/whats-new-in-v4/migration_map_autofit_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_map_autofit_v3.png
rename to all_static/images/whats-new-in-v4/migration_map_autofit_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_map_autofit_v4.png b/all_static/images/whats-new-in-v4/migration_map_autofit_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_map_autofit_v4.png
rename to all_static/images/whats-new-in-v4/migration_map_autofit_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_sankey_sort_auto.png b/all_static/images/whats-new-in-v4/migration_sankey_sort_auto.png
new file mode 100644
index 0000000000000000000000000000000000000000..2957f9f9bebcbf49b8cd8dea74f8a6f0b3eac33b
GIT binary patch
literal 34609
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
H9qRu9mwdUx

literal 0
HcmV?d00001

diff --git a/all_static/images/whats-new-in-v4/migration_sankey_sort_input.png b/all_static/images/whats-new-in-v4/migration_sankey_sort_input.png
new file mode 100644
index 0000000000000000000000000000000000000000..fb7419cdd81fa994be0cf2f2e95263d15601e56c
GIT binary patch
literal 36483
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
BR<i&A

literal 0
HcmV?d00001

diff --git a/all_static/images/migrating-to-v4/migration_sankey_v3.png b/all_static/images/whats-new-in-v4/migration_sankey_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_sankey_v3.png
rename to all_static/images/whats-new-in-v4/migration_sankey_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_sankey_v4.png b/all_static/images/whats-new-in-v4/migration_sankey_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_sankey_v4.png
rename to all_static/images/whats-new-in-v4/migration_sankey_v4.png
diff --git a/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v3.png b/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v3.png
rename to all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v4.png b/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_scattermap_iconcolor_v4.png
rename to all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v4.png
diff --git a/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v3.png b/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v3.png
rename to all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v4.png b/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_scattermap_legendsymbol_v4.png
rename to all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v4.png
diff --git a/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v3.png b/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_shape_legend_swatch_v3.png
rename to all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_shape_legend_swatch_v4.png b/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_shape_legend_swatch_v4.png
rename to all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v4.png
diff --git a/all_static/images/migrating-to-v4/migration_tickmode_v3.png b/all_static/images/whats-new-in-v4/migration_tickmode_v3.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_tickmode_v3.png
rename to all_static/images/whats-new-in-v4/migration_tickmode_v3.png
diff --git a/all_static/images/migrating-to-v4/migration_tickmode_v4.png b/all_static/images/whats-new-in-v4/migration_tickmode_v4.png
similarity index 100%
rename from all_static/images/migrating-to-v4/migration_tickmode_v4.png
rename to all_static/images/whats-new-in-v4/migration_tickmode_v4.png

From 89c6f8afc668e87553cb467d115eba912d5b678f Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 22 Jul 2026 16:19:29 -0600
Subject: [PATCH 09/25] Update order of v3 guide

---
 .../guides/migrating-to-v3/2024-10-09-migrating-to-v3.md        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md b/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md
index a24704e16..b706b023e 100644
--- a/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md
+++ b/_posts/plotly_js/guides/migrating-to-v3/2024-10-09-migrating-to-v3.md
@@ -4,7 +4,7 @@ display_as: guide
 language: plotly_js
 layout: base
 name: Migrating to Plotly.js v3
-order: 2
+order: 3
 page_type: u-guide
 permalink: javascript/guides/migrating-to-v3/
 redirect_from:

From 41a438793b648f5d6d40daa4b2b58d788db49f9c Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Fri, 24 Jul 2026 13:45:41 -0600
Subject: [PATCH 10/25] Rename/add example images

---
 ..._antimeridian_v3.png => antimeridian_v3.png} | Bin
 ..._antimeridian_v4.png => antimeridian_v4.png} | Bin
 ...olor_heatmap_v3.png => color_heatmap_v3.png} | Bin
 ...olor_heatmap_v4.png => color_heatmap_v4.png} | Bin
 ...on_geo_autofit_v3.png => geo_autofit_v3.png} | Bin
 ...on_geo_autofit_v4.png => geo_autofit_v4.png} | Bin
 ...on_map_autofit_v3.png => map_autofit_v3.png} | Bin
 ...on_map_autofit_v4.png => map_autofit_v4.png} | Bin
 .../images/whats-new-in-v4/quiver_simple.png    | Bin 0 -> 32374 bytes
 .../images/whats-new-in-v4/quiver_wind.png      | Bin 0 -> 49448 bytes
 ...ankey_sort_auto.png => sankey_sort_auto.png} | Bin
 ...key_sort_input.png => sankey_sort_input.png} | Bin
 .../{migration_sankey_v3.png => sankey_v3.png}  | Bin
 .../{migration_sankey_v4.png => sankey_v4.png}  | Bin
 ...color_v3.png => scattermap_iconcolor_v3.png} | Bin
 ...color_v4.png => scattermap_iconcolor_v4.png} | Bin
 ...ol_v3.png => scattermap_legendsymbol_v3.png} | Bin
 ...ol_v4.png => scattermap_legendsymbol_v4.png} | Bin
 ...swatch_v3.png => shape_legend_swatch_v3.png} | Bin
 ...swatch_v4.png => shape_legend_swatch_v4.png} | Bin
 .../share_with_plotly_cloud_button.png          | Bin 0 -> 21323 bytes
 .../share_with_plotly_cloud_dialog.png          | Bin 0 -> 22903 bytes
 ...igration_tickmode_v3.png => tickmode_v3.png} | Bin
 ...igration_tickmode_v4.png => tickmode_v4.png} | Bin
 24 files changed, 0 insertions(+), 0 deletions(-)
 rename all_static/images/whats-new-in-v4/{migration_antimeridian_v3.png => antimeridian_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_antimeridian_v4.png => antimeridian_v4.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_color_heatmap_v3.png => color_heatmap_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_color_heatmap_v4.png => color_heatmap_v4.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_geo_autofit_v3.png => geo_autofit_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_geo_autofit_v4.png => geo_autofit_v4.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_map_autofit_v3.png => map_autofit_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_map_autofit_v4.png => map_autofit_v4.png} (100%)
 create mode 100644 all_static/images/whats-new-in-v4/quiver_simple.png
 create mode 100644 all_static/images/whats-new-in-v4/quiver_wind.png
 rename all_static/images/whats-new-in-v4/{migration_sankey_sort_auto.png => sankey_sort_auto.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_sankey_sort_input.png => sankey_sort_input.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_sankey_v3.png => sankey_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_sankey_v4.png => sankey_v4.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_scattermap_iconcolor_v3.png => scattermap_iconcolor_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_scattermap_iconcolor_v4.png => scattermap_iconcolor_v4.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_scattermap_legendsymbol_v3.png => scattermap_legendsymbol_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_scattermap_legendsymbol_v4.png => scattermap_legendsymbol_v4.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_shape_legend_swatch_v3.png => shape_legend_swatch_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_shape_legend_swatch_v4.png => shape_legend_swatch_v4.png} (100%)
 create mode 100644 all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png
 create mode 100644 all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png
 rename all_static/images/whats-new-in-v4/{migration_tickmode_v3.png => tickmode_v3.png} (100%)
 rename all_static/images/whats-new-in-v4/{migration_tickmode_v4.png => tickmode_v4.png} (100%)

diff --git a/all_static/images/whats-new-in-v4/migration_antimeridian_v3.png b/all_static/images/whats-new-in-v4/antimeridian_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_antimeridian_v3.png
rename to all_static/images/whats-new-in-v4/antimeridian_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_antimeridian_v4.png b/all_static/images/whats-new-in-v4/antimeridian_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_antimeridian_v4.png
rename to all_static/images/whats-new-in-v4/antimeridian_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_color_heatmap_v3.png b/all_static/images/whats-new-in-v4/color_heatmap_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_color_heatmap_v3.png
rename to all_static/images/whats-new-in-v4/color_heatmap_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_color_heatmap_v4.png b/all_static/images/whats-new-in-v4/color_heatmap_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_color_heatmap_v4.png
rename to all_static/images/whats-new-in-v4/color_heatmap_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_geo_autofit_v3.png b/all_static/images/whats-new-in-v4/geo_autofit_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_geo_autofit_v3.png
rename to all_static/images/whats-new-in-v4/geo_autofit_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_geo_autofit_v4.png b/all_static/images/whats-new-in-v4/geo_autofit_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_geo_autofit_v4.png
rename to all_static/images/whats-new-in-v4/geo_autofit_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_map_autofit_v3.png b/all_static/images/whats-new-in-v4/map_autofit_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_map_autofit_v3.png
rename to all_static/images/whats-new-in-v4/map_autofit_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_map_autofit_v4.png b/all_static/images/whats-new-in-v4/map_autofit_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_map_autofit_v4.png
rename to all_static/images/whats-new-in-v4/map_autofit_v4.png
diff --git a/all_static/images/whats-new-in-v4/quiver_simple.png b/all_static/images/whats-new-in-v4/quiver_simple.png
new file mode 100644
index 0000000000000000000000000000000000000000..927373cceb1b7241250037f4c88ce260fb87d170
GIT binary patch
literal 32374
zcma&OWn7fq7d8qwDu_r53ew#m-Q6u60}|2$A_LML0#edl($X+AC{lvt&>hm<4d))8
zN1y+B-}B-4#UC^Gy=$$#_FC6<?Fms;mce*L_y`FJ2}4d+@)Z&iN)r+iavSOc#3ycq
z_DD!rNOF>58ZOA&X=pw#q$bZY<^pD3EIvj?mTDspAP7Jr#5<wxp;x;HlCAqrPZmG~
zYNN)XqIyP#f`S}kkd2LX=pc&)suwe&kU_QZ3!;n)D~B81*yLFN|9GkzXRF{Gt&=;2
zUPVP)=b9=5tr?}eR;aFGNGMo7NFXvKWK_}2AT-Wrtf->EM{FEqi2r;<OK?Q@$2Pl%
z|M?j4<RCT*R~?35?SqGLEdTR1C${K5cg1TA6fC+7BtCLPdq^mS<UR{ZeX2vMzZ(VK
zE{a5AmcNG#vL}=d;THd|Z)hTtU+wqx2`rQqTr%2!hJ%CxmO=V9?X+F^{GTzZ+Jn|v
zK@9=GqYCBf^nacLMwyFB=E5kI?AAjos{E%bGAv4<pO0+xkN$ZZix#=Z4+*pc3@JRA
zGWYlN{+YN2J@8=M6UB=@ioab0jp~E2njk~uz>I)_4@>yOBgShP2=xAxO;X~&v5!3P
zb;E6{VYfa;`KPDfYiWyuI#;O{jSYMx%8Z@KifCjr7<k#MlRr+#^Kv5}GVgg-gDHGY
z7PnKDCoOW=O?e8>xE=92&LN#7ao;wkO?~Uvm&l%@iz{+_ZaVF{mUh%zZv1^aO5#aH
z7;DSK?d5nYcdveA=W?WoUDpf8k2ebsMfN|=xot5M@xA*jbh)0h({}JHM&)ux<a+=6
zirxEuzO{*s{EU_vkDb1^hd*eiW9il78<P%SKnKNo`(%QkSe64V<LM-EjUqMqiihH4
z$|#UWbG(e%OsLQR(N?b;TYn7ha=Y0EC$pmonCoU?{`Qxu{?L*pd4l5^$AQT=31D-h
ziyrOm50nw*88_P&u)`k4X;$wG1^4x=U_DNYyPLB!D*`Yy`sTb#1ePx3K6RhKV4-8~
z`r=6c*Ip4S+PSuoXAQ-u!c6-6Iak<9y#5rVcGev6VF_%?I(;LQu~a9TyIuE3!&a$H
zaaoI7OLrhT!DU6iOgW0LGZx)k##9BpF1ac;3dYmIKzXu3F_aYB%8;8Sg4X@EY=0@J
zTNT@5eHU>7uw@|ngmrPrcD%mbf%w_g{9TLZS>rrcNbSj({(yOZ>SQ(-|BpfLY1^vs
z9oV#;^HK=y)JlSpoqf|mP&lbbi_~rDhbSb^l{jq%&6>VsuHKhPABjEozrlv(87G5?
z>?}R6PHWIvn+Ds9OfW(UvjHQ`xnJchL6?p?2#h3Y$U#$5nJ(Ve<DF(fqW4ibH8P(R
z6;Ptw-RybqjHs*BG@nlOdMBkjbUr_ww8*$nSPxv1gyY%OEk0oM3Mb;}w<qn8Ntpko
z>9JkWb^T_6&v8}q$AxNoxBnA<I{Sfiq3JLIaKqgX6)%&u4DS|Zy=uCQ+l#e~tI9dg
zGjQWpX`}7WME1FKf%kU8D%J0RMy4nu1x?iSp+AgZ!%nVObMAXwu0Bq3Dkg`30mD8i
z8fuQZe?@*cQQEj`Eko*AEoCJvvAffJHh1Jn!fq0<Q@@t(+(Vx~ad$I+xALklemo&k
z__Dit=VaU{V?J*rR8r63I-&LY%@yF0p*aduDfTV(JGJv(c~&%c*J~mQtI=oYfD=KY
z^Mph7Ihn<2v90$C)N%w<zCRK8$=T9DWG%3xvS~z46z4diCUdd9R8)y6bgXK>1vyyi
zFih-KXFi?cv1>ljqFzaOcLs#Sv=@rWoImV~4>dBB@v>i%c<hU1;5S=^`s>h@P3=$5
z-*U@ab2MG;HY!0zogdZMJMYakk3yg**)U7RM;yfOXB=R?ER7SNs1*)}dgGZnb~3!L
zmq|TSPiKv8HnqLLaC{o&)O8U`29@5Y+6Ig8<2>$lkVHn+;`iW`Q>!#2t4AM)_4PGM
zOCMX>MhYIvii|Ch@72}e+tFfH9qv{Q2;aJ7(epTl3U66E+GNzWRX!SzGs-Az^IQk~
zjOFK2nE{<q;edm_6N|kF{5+)oG^U^}S0UlDV#t9yRQ){C`}#Ynf9TbhYRe&Z*{kLV
zo2AbOgKHx4<7+F`aAgkSBj<U~_ufC%GO~|h;-13Q16K3!H3M4MrqLodq(W7%TEvPd
zyjhrsUu&}}6W1cVxs>zi9uI5t@h6c7yEWs6>At6}mLaFwaX(%$gN7%cfb99ZN*MG@
zST)jC22ywi+`m<~^e_~=?7dzju$Lja3%B?94&69!x!SeS3V70UDL#s<iMH2z*Rp|b
zv@=9)AHskp>$xFkNv~3U4TLUOFsauBIutx-<k-iR^Vy?7a2isZW;K+m%`C7}tu72+
zGH(k&J3T4$o*i(~6o@+qB9|L$=95c!o>Enr=Z=k+p6^sPlsP%&3+p{kauOhh&23%w
z*?Vz#7uKh?6x>~+03q|ehS_8oD0r&!_HrwsIlQGQ?xK%pUSrTi?Q;I^_PzQ%Ixd$v
zp}>jK0Zt^~jE$aG)AOfC>MK78@@dmu#D92Mg@wa#9p9u1x>lZjHF`hm^is+63q8?*
z$X(OTez3@~x|+t`p4XW`<7QE@M|vAixV`?BsDy;S6-h}z5Db29GwIMp{063Te7_7g
z4TF2)t9OVE$uZzv6*Cu=@O%}X6RE4AB#ZP7p)DN64ii|pxRTn&d~2&nedrRk5A@w+
zz6vQkb(!uKc;<j)lUyQ5Qtd*O)<ds4{4!4}W1h~xQyrpbk>+H(JyCJ{$oG<dh-k%%
zId)+f4+~8&yq<TnUFAx&I{Z{>^sEh?H8CKylNA+3Jykh7$K#RyRTF*52nEUf)!dol
zGE-K`a@&CStt0C$`cbW>U19aR(<&hTj&Y2)JR8krAJSk3v#U;LpIc;jjv4*1-Z?7Z
zPW3#U%!7ve29%V(Tz^*l^4N7qE-->R`F$DgTky9b4JKmJxcnNat2ANKseHh_iE4D0
zGb`w4ly?R#RIUnFPi49q+XROiPQg1@)(NM`VERvW%ro}4M;UkLreCLQ%69V6tWu$G
z3bo4&op)-+FJm$a1jSLILBL7MaXbNg?(4o=--XYl^ZJqkj;x+7N#R)4$88f|mJ<{Z
z-0t7<5goIw0gq9iggK6Rpn`>KE3@d@I;=gm<#nvKYqr!web>rgql0g(MzM3_h<fxt
zvm&{c)Xurtc-QMsdu{2@ACjnf(*I~IVs#4<MnlTAiB3>I5?y&7{aTx7WR7c0N8*Q;
zveAPlFV>S3eqDw4c*Lwp8r2;>h^r6T2zVX%RI7Zfy~d^Zi+E&yz_)vtg0FFi5Ak}6
zSsZAySO-d5%ueo?;)dFk)=Q^cy>Yem$iuP6Q9qP6bX|#qoz1zYv_xTwT)&MGt($gL
zUAfOV!xZ63#-MVwXzz7IM8pp*xWgH@SonGmv)X^=$H$g)&4f4?E^h9rkwSG(cc)J@
zzATZSPnFOTaZ-NeP(7i-%RvoE!APCZYHHWSD`R|u^92WA&7eNZt~5qR&1i%hjbZkh
z4!gPOB~+Z|v_U*`Aa}xY+X?40BhQqfDa}BhGQVbN-i#$UqbtR(K~DEj0f<^2LD^4T
zpE^<Gd1_}oMYBgc_rAND?|TOWyoa;K)%9vJq2-wRE-BjOBLlFrZq0$M9Yat{SWIWQ
zoHHP5Mi4YrMm08ySux_3YZ|Eh#E)!W_r!H*VpAu3Iq8tDtSRr(pzv`<#rh6#RB#ic
z$7*ZK9lNU4UtSk@UvA^uy$Y2wc3W(CLCl~H8J$p|+L8}%_l#9ZhwR)PVqrdG`}zQb
z(CpnSOMS5CurSsNb%3Y^kSYpDL_$)q2a~SyQtURH%LCD-?OQ#wCJUX2yQzzuqCP&l
z^uF7>OWKSYmvp#%H$)H`kYvkD1gVbxf&1#3nihL(^4=!CzU^Y`h=z)O*ya$ya2Kg}
z>OdY$e*eDMsRCn0l)jo9pXa1mjFQLQyA)=g!CW;@-_2el3d?#Tyf>(R!#ktTWU)3r
zQ%y-4{lZZs6zJIKWkE&p-gxC)-AzQp&V-q|G;#);pi?Q7qEMvOCERO+dPetZHMCiV
zn38_zd3Cj76&B!)$68ht;BCV*VI`2}VJQ*;Q!9uecXg<lo1!o-e&<wZ;7XNE#fDer
z5TB^pBw4XkJvS$nZWO0mmzMXvKv_wO?jx(=xLkUGxp9+Z*%bA`XO|t^%a28hlX}M&
zHyL*qq>Q&e<F8!RpXcI-sCE!|J$ZwO3Y<GKE87+(w@YEHMUUVwtinTd7=#<L$%B&9
zvv~niDbZT->wfycEZ>uInYvMx5ZPVwp(f9|#`#mxKvJc224;!P(3;FmOoEnkb*u??
z?$coYq47T3z=H<0S0-AX5li~G%lu*yho5;rZ)l1mebcADr-t4)m@7lP5PFr(y0cUl
zG1VYR>+l}PCa)-tr7~HST!rz-)yN&3fOzjF_O$PwdI4))ch2V~J?OsXL{e_e%VTPm
zfyyTLL*ZhKK%+V9;wfBL$FS+l<J03@m#Z;bPv1iD;jk1%bxl*p!R1mc+31_mrRwf6
zoq~+R33}!9a&h(?;bQwk!4SD>pxx`_&MfGPO?dcW4NUggdT#@-5Go3M#apSKUeN|}
z{pcvRv2?)aaPyPv2y5V>8Ka@+E1f1;Dn@0MepQ{iFAbYTf#zXOV9lu4Q3anqMEOMT
zNBcy-*AbUJz|r6@v{Vy)j=iLn%8Xh`D^%3TTQWE%r<zsb6!JO^NxG?BDjWRe5kX(f
zn1$%Hq(b4rutr?l&ZGR=?wBu(N^Tyh%92oOYKCGqCQZ9oLxz%>8%0B<6D8V*{AvWO
zX!_yNozf(41I4fsJ6{%6v3)$%buC0+&T;ZIY%d()mAX>Vkgit3vz~{05r8HSJ}x~i
z63n#`(vz?FFdQlo?&x5EWwwR=FgGMn-1GKia=b!9TVPDjh8gZ4Va0^?!5_(w=SgVn
zBHDT;{a!K8qq$%83~V>nSRk*`T;MNxh*8wG_Q_+7KHSlSI+nC89}@7R$9`W2yhkyJ
z8mRP|)(`Vosm}00lm7Po+p1U~=3doC&iP$|`HKke)bWhlV_J~`4LDJ@JP;?~q(Ici
zlHx-5&-C=Pf;lh-u{aciACh{MXE096!?bd^o{EJ)&<ugJL(_GRI%1_`IMGUg`Eoe^
ztklJpLVrVSkeetDK9$X?n>K@&zlE-KWpaR~gH`>abqUg2GwQrDIs-2d30!<4u$}n}
zKP(`S!U;{=crm+oFVOkmlA-v^QlPJ3-Qn)0BOPlh3wf_Z5&O7Y1j!EVfXTtB+_Z_I
zLGb101J&s`8oLI5jcx|L@gM$&k_tcvtU~-Me)M{r%(53;B^zh0cg?Lol;IN4!(1!o
z14(b?KUjb~qoH5sn|if$GRq{bT`!t%#qXfv6v$<!nvo<ziW#`BY+N03v|WdJ)<0uw
zU540|9ZHBv{mIx|7ZrBSaN4F|Tv-gXfu{oD!G}*-2pbD_>4Z`BDnAVK<5+Jy<rLcy
zz7TS&&TuTdXmq;_iNGbMkAaY>hKfoQ$}S<wd>qFHw4(FO>oV_~Vkrmy4?V@|iDa1F
zHf7CP&otkGkFNa4*!lwD3H43fhxk%SC--yiwYJQJCA2BzsolO47Yf!|DoJhX$$^Cg
zuO4iEN`EplWk~WWSEg6H^>Xx+3hjsC-kq@3sUIl>5N(E$7>r}Q$9>qN*MqNIr$TXU
zW}#HrH3ywUwaHw-=1LR<>SLP7cor}anQ!fdTbp!3V<zZHNGC5V)mK+4h7##A>KH!a
z3(;y{864bFFP5-6fyqA{b`o3ngywx%AFjE4)l^NxUmY$P#qyp2CYKR1W{1V}la@6p
z56|kO6Pf^OWwzuNKVR&#cvLOo!0D%@VHWJYZO0L%TZc8JZFqL9#w_|7*n!rqf_cen
z`acyNdf;OeL!Uig>QVF)I<h|#bSckp{=6I@%m|6ow9~7<N|OB2-XyrU`JR(m%tU)h
zdzq4*=|Rb8$xY7ty}8@OaXpgovL04t?NniPh8$icnDD@*!TJ%ifF4!s2_Fuej-^nQ
zmg2C<rls7@4z839Nz<SmebQ3`0f2=mlKIe6Wgd|qy_vl$4XMnm5qTtd{c9fysfKdy
zRkZwcDj$8rBxE9!u$nDc63D;5rLYX-byad?1a6o$;Vh(Ey+(7yV1^M2%uqY8p<JmI
zt38T?TvmuD-$tc=MIr->$`Q*b?TJykrR&6TA~jlbTa(-8_@1yShJo_kR}ld!e4az5
zz0j(V^v9|?&WjB#s>j{5XlfxZ+35|SeyWK^%h^!0Ad%}u%v<{VmpH@J(ykx;$ruYB
z)zTY`C(6!jZQvyb7vE6GkB8GAR&Uw8os}$btCl6(dSxDK?`o?N(H_u3Mjd}_h5{*W
zsEJ%3{{hX(W_fO71YeH&b&+tc+Cqg7WGfzy-!XU+m7k2TG83u@ohn?p6}nN&a&}01
z4(V)QyG?1IB+<pS@+zCiU7XbMqBYThw@fGpvJWK>a>c_-KxMmQ2^M=mIlvTGGV4Hy
z?rO!=Cwr9?5Vsm>lRWT%$abL@4h8icjgH)_z~NwS$j%%H7#Q*8Nn6-Nd%?iSPZCnt
zS$MC5Yx=X$RZ_%z97lfaVUOJcG9{ZqxvYqU!*l6_jx1#jXm(M)v!$9hG$*NPfzW7W
zT&XG<mQ71*sa*F0bLwH7ii*DK^B(Oc%Nc67lZ(NL^&^U|Kw%Mn-EoIzmy|jPvA$DV
zZVbwaQilFcn8Ub)>xmL@D9$gF+U!vaQ;q$qAEXA)4&8h>I@~zm?RdJum!2%*wp+iJ
z+`<b@XxZ%t-+trL{{$Nn)1AvO83+^%#!+tgQd;kEi8ESdK+S)$lER$jxo4fQnzxBA
zee<c@vKX{7PAxCg`^r)C1n=SOi(Fv>J6hJxaGtq!@2_MHFBmanSvVMs_&l-SqtUqb
z)hHE8wP_v<c}V}Ze&(^|P^1POn3lDHipiIiJfB+{5_TB>h+29D8U8Fp-+=_&Fp?<y
zp=aw$Lwf<+{Ncnpy1{f0ZtjiT`+OUBu=SW%0jteyY<}bIi3_D`O^p$Q%BQe^uynDa
z`beDm%@k#P3gcnD*#;(7b{dDG#$Qfy+E=xwxnr=9rIT&}CEci~m|)J(aSb#y4>YA3
z#!%L$3>oRiS%q|N4S_7|2|eR;ylA>;EJC^BrkNGdJSwz4fp0ddvOT5zlp{rPdD4(9
z=UIM^r#lH@h%0KupWahq9v05T9X^d!XRvoa<w&!YG*xwZJS=FFhPB0!yKGeGmd%@n
zw=OA0dojh+E=?<q6WWvGDb+<wECQYPQD&e%b)xuEY|;Z9H3QKRg;RIOc=yv@D4^O9
zekfJ0fq`Ef;7ly#IE?dJg$UQ;Y&ndGJ;%aA29?p3w@ZsA;IP*J!hs9&5r6#!8T{5%
zheG`MWJblc?bpR1LG+VBw-@2C$iuBq8G`K{M=VYuuMQ4BO1q*<coxcn<TB|q@Ix>|
z$W~%>UZqMFY_Bl$uPZz*P_Zt{W3VLhblq}L(qlC^re;RY<FB6aIO@9%<~_E2>A8r%
z8dvZXJ;c#febhT7l5XJeGP}3_FhEX2avCofr_@@;CakG^N*Y4{lhQt?sd|ZSkpu*B
zch;1ymi=15<XW3u*QRPpH;{4p#be5X^ES|RBpo(U@Ho6!a04f42!=DmpuZyj%SHsQ
zq@dQ&cDj4-P_{@ALd0AWm&HDW=I8ZReELHUP`@R>!cVuBV(^rVqZ5Z*iu!OqOhumX
z4Lg@G<1|i5Gx=v;JPV1OBD1$xJk31?-(>od*ymm!mNT}V7c&Dhs~(`s2rx4CIB3Y@
zq$~595WR4EnfsCwU+tC*_4-HIsdoruWi+I?DN`-|6(nL<J}~)Z)=Q0ed<d&UZpw`F
zlvVyUO(^RLpH>iTxMy-eBS_gxvsE~_GDoUQY$xN;OU3~bNGO3Oo+kKVxxU|6)x~4<
zN5o}bL$%2IMMEITn>a9#NU=-PK5VeggJ{B1u|mhWhlcUPmN>%?4o``|2RQG+YJ+HH
zn`7C<k1wy+>)=yx>TGUo@k|3C$iI_|#{3sh_MJdorzbwt*$Ry;eI<E+YtsOl-PGic
zn+-uFFBb%!UBQ-r&tDS!FP=?}EaawW_|7%QiCWZghU>k-5o`q`p^HCagI06Wl~B_G
zcq5cDU;H;zULc5U{Y4t30Zof%$BI9E6?@B^Pw8kd{6|Aq4&k(7%CH>Lx0HSd1<hio
zpi);|IpHS^nxd9Wpv?eLn<L(>&sWf@$0!ZDDm=>@0^(;fmZi0;cUzr5+VUG?)$nx5
z25A6r9hpSyUq%1{gIh-e#rtVzED3@>SZ6|pA;zt$4#4ePT&d6p{{x~Yigw+%caWPv
zy!D%+0A45%2S(5E0xubajQTkYsU#5bmG35v&qB%WL6+0sN6DB$MX)r~xgugh!Uw<E
zh~HmfJp{({0+0UQ|BI-2ig=yvZIS=qeki`a;sZMBsmP=G%P1iEvXJ>K?4Yb`p!pu6
zMdALjPCr1BILDJs{~-mUfF<=2rA1Vl$dO9_GxMShVCI)yAMoQ<d{Y08H1j?%By=jt
ze<_J!WuH@^r9fak0y%a5wJGAe0>prliG~jaB>!VMR55|)PS|>m5ljOTXo^CV5LnD*
z#9|76h5m6MWYiG>pp$xcq>Df62t52sE|cc|-git9TNx79&pQBe$L+kW<Gviu^NNp`
zlMrZ7lnW<Q3DNGbG~!YBy=IF9L$|_N&$HRnn2hUofKf=T4oBblZG?Xo`9p}PxF1j6
zm{WP;&Ds3CmVtxR)?9NVr1j<$_I6QRzuHpmp@J#L|12seZh_o4eO|IEivbt_seHdY
z-cWzm$B!^;4^}4r?<d#ap>Q#~BrxfkB!Hch!U?&Gdd1*Ke;ZL905w$ZaWT4ZBz*+G
z{dOPrgC=ESFiWEGlf&%j&1#DMlyNYz*87{?&?nvi@sa1*%(z*a&+l~D<Z`g&w)rmM
zxTd0F2q-89sh!64b6*H-LfSX%l^z+Q`Gm1Fbi18wz5y_A&YZ`9&jlf2{5#!tmCRL8
zS^F*k=x=xI0sx&A1_sx7$N3qGe89hsl-Ynfn5=^~l1k`twNtwjEkjaqwbwcygh6C3
zu-8;&WLLiuuk%gq*<bhe5#>i6NnHSY-<&`?KR##17b;>RmJnwoSLH^2`G+x6ec+pn
z+w|r*iRq6Mjo=~k!!<#|SKAx_!~#d~GMhy-v6`%YwM>d;0Ppq3>~vI_Mlhk3SoLe%
zibu=E4#eN|!*j$_aL7fo{<PID^ZH~|yEaCd{|EQH$I<yCr2;CDz4&W-{C^x?H5X)w
z4>BPi%#p#Ie)}E6l%8=z9IHtVH_zj*L9lRr2@GAn*)?qBvFK{NSDY<yVMhcV6}dpp
zzx$?$l5FUrO~lJ|(ISSSp=tlvUeQULIO-))zydQa-sC@|q%hi`4XOr_FEcmT<mzU9
zIq!{&T{G{;L%c2-XMtf&iy8+@6?d$roh&KCzr7E3fW)=EX&y7jpnw1RbGn|*zAKTW
z;nKjN@J438^Cc7y<!?Y>kRYpOV|Au>BT9Rwxh_>^BaQ=;gfa5h+@a2mJR!#T9h(9{
zmN+1?C|=|cm5^z=pRz~-LqwCt(Zn(hJ$5Cg2#yHhbS2c<Qi6W93_-rqf7wOfLsUyQ
zF&Z|T#~gX8OWMX}Jp2dxmR-?v@e9mlqu`WcMv(pZY2wu1AR!uxX12C&&P2rTU5eY9
zgmRD)9?3I1`pLw^9Cc0ulQbL{(6Exv7$VkKiXg9j<?5R}NjE@G%jY?E?xZ$*w9N}Y
z*oS$iPW&$$=?|h3rnX~zZcQllFhzgP9Br-bdkWj@(Ep-~0}g5$0gr$TPc?81(qLPV
zGJx^@YKPkkfe^AzhYb5CGRkBITJUrW2Ww}KxO-7fuRzRY4%8+hj#c9tuC0Kz&2#!?
z$@9n8oaD$jY2Sheh?F>-PpTiRZNw4dPqOFb8|=M<Cr^u<|JQjTIhM7&zhk|8z-DK)
z{6rBYmybLr9;Q7Soun8L00tlawrqhCit<)+9;>9uc(B+QJS8&H7X3#3g<g9thtLic
zc9RvU*c9f!h6UJLYZhikLk{I0{^+f_l*#0=g$~=MjmhERFr05Ga}_x&f82e999f9s
zr;0_?gwxF#PhNdFyM=qCy)R%~MwU^)3lNJQ8IE-SU$Xm^_}8#mHi2TTCGJb?(53V4
z2uh)xwpVTW8XVY7xdp)a^3Pz^QJ{^NXtM6sgc5U(`ea^lG}tfRyPc?8H3p*2!7id6
z{dK{jP*EytuCg%|)4|kPOMZXxNo7!1QfXz;tPSMnA1vUJxB!v=0)&>WG7Jg*&kBR3
zME!WGzY@+aeIHEyiIEBs9y#_O%<V|BD-~2YK>wDq^et!O_dJ0eQ9yzM7A1o^aR>Pl
z)Q0z?ragoFoc4W_JgJL4GkN^6n4=GvEN3JM<d0o4cToeBXUyMabDLt&uuq#klyVl_
z$SP*-%fxQ_5lO=JpOa6Z%6gbLtwZ+bW(Gs%zNDS(a!(%Q1{>S<?S1mYY6APE$s-(m
zgcA7@h@kCaqEj5WybfDhFO|2s8^o(%VK(L|xb6Mli6q?CHyt}ZpOSt{naavp{A(gg
z-@(*!j9DCBcA`~DNc4_S3wz%3Vz{eH4)5PhkK{Xs#v8sRREtwHxq)sz$<`ehFX}ev
z=Km_nFPP`Pza%a>l5Yc*Xg*>nu~b<6nD(Z0YD7BR9|fB$@3A^p9aNTd@9H!ZmzwDh
z<Af|I^~w(Ycg`-Lnx$U;v@ErIrn8>U4B}HG;uUyH!An<89fZCUksGXR)>zcI-g-1j
z;UX{)h4Uxe`iR~~ll}UD278KbXsg|_lR5fav#AzrV6eeZ<wyLnnE_<KElZCD?6F5E
zBWQq2WE!HH8OU(pRM}bK2dxS=`f}j|fsS@~Hm`K-_?FTIF5q1K;!oniPlYA_m4Cpl
zlaLAi5}M6(dp<ZCV?OeKo3XU(Ijb`>tz8VJ1Z^d_1`!7HoYyURLHuGq|0F16H9&|U
z0&j6BAHz_;e>sO>ldkN&cI$*>ta^j&lVu`df3llFdK9Y}9XPr;tFzOx-YNZKSAnyU
zpr#TJW0s7gVeZ+9RagwzyrI4+eu==3r^8<c{wKH<h@dF9>g61b1Stn_^HV-Xu}~OU
z6}Q)itG{TPtv^=mVW)Ia7xv+7#Q_xn`57YVQxyXJTI~BJSe2Bz9^S@gFMtUc0FN|~
zSZUmOR3h_+S!^Gc@m&93SKN$2YA$_*f|KFKFR?CJ)~3i33%JUCXM+u6ou}Zvx0F~-
z#L`_sf80tm^APk|h{LP2)D_dNQ|i|ao$#ZyE}n>EHdKcBp=UOd`<<vU*@DP(f2=7R
zCAuzYYf4u!9rd)y)nUuFgJ6oqK5uaMH9yH5=wWR3zcbyS7VRaEdW@W}s{|)_iBlB_
zC%~yW*r(x0j{R@jlMVWbt_MI&3y6lZiQu8%zlzk5FSozl@Yqqo1g9|*e#%D8<Aff(
zRulTO-LWh&k(F3c(-KE#W`>QUPLP7f<R_w`f=xTmDG&e64dk)Oo&c$BjOcn(NqClS
zXUJS<Q$CNbK1JitRn0ftf=!xyOq~BpVi5a)28;h2<3MS9=@?*n8vEr%W+6hk_E$82
z`z&xo!Kv4+nD*GUqjKZm8?aAxPJFlO^4n0PKvJrLatvgO1x6^(^Mxhu3M#e@3|PHl
zU}@TXeeFO@CJ~x?@+T$}<Dg!vKWln8j;2OxPUQvmFq475plFQQ$YLy$7fTpr0@>>(
zb_03+2($0oET_Be*ZRhb<mPtGc6@^lz}Bz^_TY!Ub1U@S^3STyS;5+{rSIp%5?)p%
z)}0wa2p^zR%H*iX5V68A5?m&@x-RUGZHFPOZ9*A^mL|i)`tF`hCG|V>ov-3(3m&(?
zwl%g@0z%aOzB8IL1CZ4Xi<22#y0jE74!5q1>-qu?IH(CYAV%7U(HU?FqitmsPbJr+
znBAoW_fMArdo7Sn<EgFD%)BCvX$*~0B|!a8cSlnq61NWBre+}BZ9E=UfRr_#R+>ie
zb&|NPlarR!7OLk@^$YB!8Uc^xtWOa92>}JvD2r=K6g<~Wa@S+8NH>5mAH|KLdqBv4
zuqo8Y66>Ng{6vAwZNc}U?bsJxZr4LIAcZ{I2C`dNz2h3Jn_jKa<-jE6<(p7q@9P8M
zJI1o6r6bSlgDz)4ZRB3T^zDnFF!?GE$o{7&{S%Z8T2ahH&`Z)p&jYu)YF0xIbp!Rs
zHi*SyP$pX*v7n)S7bX#67%~qWal4jo>w-NU#A$qvdEtOX#|+&eM4XmU2+_ysf<Gp{
zMHNsM{E!YOd;^e~c>}e3Emu=OU9o-Sc|0To1E}%K6RLS2MI6qxMHM9*1<5NJ)1@v&
zZT1hjpo+e}02Oh|M5R@2N!m+0I--k*fJ3JK?RAsBlihw!kcju~Yhk^%vy*Z3R8W1a
zR2aT4AV+!^KS^lw#Te+Uw07kpjm_Baw^RoqW{FV|-dJAtQb=3y1pc&*6gn+OsE9Q2
z-=%4r2+I~@kRbz3i-D4x#}*q}96mRU4vdQ$^s+SVIqf@Y!>X*t^Vo9Y`2BrrJG%^F
zPXn9EyJq(@*nM<-vv9vN44#=myVe_L(j!17GdcTyK8@h3X;(xILY4(&^!P;FwuuOl
z&gwwM-cjd8Ji|9cQI!nZ<KOxMr}3BXduUaKO*Mv&e5v~#)RxPkf6QWVX&J^#fe17j
z@uFkjQyeHX6xQ4AXkyp<IxQfzB&H3FEm8zmr#m)>gVJa?Uqi#T=|;k>4<GCSQYdFY
ziZuoJ!ESStyb+{k^g8x~rj~ApO32{I2Y{^ClB-}T#A!n4D;|#K$V76JYgh}*ri7CL
zHKQyKvWU@{L{(5t^5sx@-j%e2L*S8H$}3%e(KOu5t2l}%G)I%M;K}@#W=-o(2lX;>
zZ>XG26*0lC9XCX5uYG=)5_JqDadhDkOsY+^dV71TPXn4Dn}$bsfQwH6+zA#n4|-hf
z+e?Y6cI9WlC=hzA`(ouYyPLK-I7edf(^xNoom)taB@|7*&c`_)oM~~21U~;2<Uzss
z+Z!cCm*D7ntnX%B>%<*Rw2c!#?u0^y1ZF=wcM-ooKSxMnXqg`qCkvTx7G1+tM0ViW
zwFAOeKM`7~-<2n9(p>lw&_11I&BYq2cuu%&mAvU}_$<F4KYavS^=HzpY}fhpCNoX=
z@%K-u#-yz74*2$UoxPfZL<AQ3985OPK8YMNp~FtL<kd;yUFvO&#)L7(UFzeP==+zz
z4B>Sy7gzq$Kkacco`*~~b%(dxsXa4wTkm1m?TjLqusxf7Un}v1ul<SOzNpB<_hHPi
z{mFFK)#oWf?l2>70H@t9|Nf*3t}M{UxpwxEqksRv4W83|40<@5!3CM(^rmjL7)X~7
zbt;tmHa+Hn<=L$(u8{0|I{bMn^IA0#m$bKG<;CM_HXS%2Q6+_TIZ-2IZRvr|#6ERh
zW6V_D83ubq<4*>bGKDj89ojpgXFKjD#Ai7C2OIV}=tS3W!k1z!v8Yed)}5SZfG}LE
zA>usaAkzq_Wt2>ufReq}B8k@_JNy}Y+q6EUCJyYrQ{xP1-lhP*hlmYAYi<EG*D3r(
zo=S$@a#v*SH~)uMkR`8Tpq_tR_*VGCE}7W|MDFGKXmP@PQp^|s$|}=mAm0!k!AilU
zU*&B@Yr3^HBvo^s<9(#B+|I!B9YWTO$9JyT8Ckqn(RqM0!^+aq2eNm5wzhObhRW-V
z$066#Pbz9+5WRrWT*uXWJ{V#USQ^nCAs|#u6TMj^H|wp0I@j4LeJ2|RNGrc$emxox
z*^_9d<|CC{p>0s*{d=s@QDE^4EYFFr{m@Kwm>d6S8)8Ucp2~aT{BfgHN885j&PIHH
z)3-BH<hE|Z!Hh5z*t2Tjf6DFO@D36v8By7FhUkkxz6Cx<GbC8uQ5;)NsWp}B`aaEx
z@>CDr6cx@rMQ1b(h!!oAud*y^=__9yiD?l0P2aH!I02m+t4CTQMl&r>IgP-+qkGEs
z_KSI%#v34G*&ylEH&SwOsgia1laeE$)ToG>Xv6V;eZycb?;QM+l;+?!*7XqovixX+
zfws@=zY{kT4|xedPzY(U%!KOdtsWciT45NQHL_6-l%W$n?TjMHOQrMUS-B^B^fx_Y
zMR`6xI~X$gQ9UcSty60$=bBiKXN?|)*OE;`=|YJUfY^_}b0M;)AQYRQiEmQZ<6KUR
z`}@PDQi-)2dX(-bYY~PlK<+;t0<fcItjr9=8^cnfJW+wl+vc3$EV|fp=BGerY1y#2
z$YuDqJtUN;fISZA)l$?Fqw{$L@_CjawWWh0i(h6Vppb;d#ge+~!8q-#UFugDBy*DG
zuju|7QZ`6*J@mw6EM!oz|NFF=z_+dC9JVXj%Kp6I(tgf6AY&GEt0qQ?qZJMR-5mlO
za5X`fgy>MY#guDW5WH_xAEk5=2#gH>yAUcU;PEXs+vGelhm>Y^=B**69%oHwaIk5?
z^KV4=Bt!o!0}@Ic1=gxyQ*@nX0blJSYOklAkl_9tgTh;CHB3Jqw4zuv-xtUz|CA`A
zGXN-&DGABJ&6*r!B6?8Ih9>Z~ChrWWb^a?yeXFrD)7XJpJh+xUwg7{Pi2IlLWMH;7
z?CFPvuPa+Xb;8m~qR~PJvR_G3r~JDJ>uf+`NO!z04JW8H9=x^)cI2t1_g))5*mrjM
z3aG04P+$M4*2)b~4q@Dv8;^A(A)T%s)aFkagda%|kWQv4VSZoXE-vC&SS;CG%yRg>
zTB?ztbq)Yk#NsC}mZIQ(gh-x%ELk9>^xc%TdQCpLOR;BwCF$RRSW1%#K*-fO!Q^rR
zwp!kok3sgAolN5<|E>X`fsPjKEFAdKHFn7J*;PQ@tkEM2w<Db8CvVwX8u-ESASA<l
z?0@SQj%T7k9cm`jWSr>E?~l&mrEDL)vqbGIL150G)c<0xVfx29+u!cj`GMsBu+CiE
z)t1^T1``9bEO$|g=#O1}M3u1K@{d=-aZ@MyK=}OZ$+f_~`yd3S5a`=a9FAHY%Gp88
zdP>O$1K2v%xKUp*O1`~}t^-`$d28}Km6?5e>F{FKt!voziT%_W(O<X$z*42iaA`!s
z$&XF=^i>iW_?e0Hhrdt1Bw|OT#z*sa1zrLw13&>Ph#Ya>74Hj_9WYq8n=QbK{ZJC-
zr1fI%U<KKSK8(zxRaoedxqCyf?Owmr*#E3?rA;8F<l`_%n}OsH7Em0AwBzSP`xahb
zdtv%5kdihr0z>!{4=NPfcQ8a{Z}CLMhz_d}Z3<@+JTj|OB(>k^7cFib_;t7=V>+WO
z$=LKkh8gV+G~(t2*5x^VdwFHMjses-z73T76JV7~VUfeD)(cbr2<$V(Bx8Q_bI=@_
zsu-}au0up2^KERD*e?<ZIsy-jSz07Eo^HQJ(Ij`l^^uR>pxoar-kbh~>t%EG#j_6V
zFoKtIbEtoze7rsTy}#bZcFz1hkaUTlSlrxN<e7?%98K;%V_)p1zfH_C4UQmJBP0iX
zq9tP|`jy_l&~_be>H8)-pS!M3)kGVnKTt<)&)72Pyw$5P4*PM&SWk%6^rIs87ao?&
zb>v;Sx-*HzLx@M}jqy@5?CrN~{1V}dAX7+MS?MfA`iFSX2VdYSgN{AiY3K7+gx!!3
zF$Z*ekX^D1hge<Di~<FP9TyesYMdqOv?VvK3~tneUqvn`?M)0FD&w4Y6ofeU?;A}y
zVz!tyU!GQuj_cM)g?x{k9&Hga3C2G_0QV;{3j$YOa4(min0io;a3}4fE-YdNsA9d@
z@n?M34+R1!A<n$VBvUiT0p%~VifM*~slhH1!%tO(K}B&sEln+_;o&<L<1dWoi7%9{
z_8LjKZ8psX9#`hjzL;Tp0u;jq_9$J-{3G0Rr^S6_*K27Px6iUoLn7z}c8<c$H=bdA
zND*Bhu~^Ue&RC(pNsr;{*c~4ldH9|xZEe3(C?fWuZz$G;U2WO)^Hzaxx6siW=e-(C
zy*;mH+oP<M^9F5$nv68hX*n;U3Z6$n2xeemrcs%jm~zAg&45?{`go{9vI~z`KeiLa
z_ZKQC-b($rGlL~M&A|H;>vK%|!;gho@@Rri^N!Bv3o+X#YxC6@+(rXlrzw=%D_w>M
zB|>Wv71a5>=aRqOj3#qKg<l%AO@uV#&EcijB(VgPX$VdPwN)cjxBzue3IjMFKc-z2
zZZpfzZpSV01g!YvT`Y-)`gebK$@`C@%LL)heG@6$KWAAgrO@#wcV)J1*XH=fXox-2
zSoasurKjQrJp0Oy5abVV7!p%TXEfHTG+ee5L1su*YGymPx9vSfE8g_{;JM(OBZ~t0
zvc=Xx^u$G)v%a1VEHjsz%3{W>%iiym+}Fb5)^rLI6`Zy%ogHu%oZdYjg?h*Q(1m-M
zcNuYYiUe)LBZWD@p)-3QNjm_!9N-XKO0P!-WG1-3!>Xyn;-?zRn(b)~ggRAXhL?No
zT5TJM@A^3OXNXkcqU#170DLB$%>zx>7HKA@^^2)y9Qy`h5Z|XkilZow`6_aIm`Yr+
zqI1<sYs3ZiYPy^>nyNj!4YJ=JT%4W^=wc~{=iQD>Hz5E@y5O(RYtvuH+<HZOdaf~h
zI?q0KAFWE5dSG<*>1Hd$`--%}_40PjQ_t2OPvZ<EF7q|aAY}HVu5?z|<EQ4I06mvQ
z^4&j4gdx7KqG@NTzzx2D>3Eo;;mjWCHSyJnh?nt}?a1|HL&L@Ac?Qp3h8RUe%#?iH
zaeHI?9nd;jdtD57-rMQP_cERrSr@oXbi8CCm^!hz?T0e;SeV>LNh8AwGB>tM7Ux!+
z<EG8~*QRCRc`>n+`-?M?+ZOZu(|O=`wI}PN-<4Z0c!}I+hhX9ZPv7yOBC?Nm6;U{0
zr=fSX$m;rp<5q|FeisFC%u-o6&Q_%8>u|$k>-5r<_Odn_fn8|GHm9TXexB>GrF#k}
z{l=TMp*O_z=1m7Hq%s10@{{^>_Qu)Pkq8Hf%zBiAH8(@-GF|CTE&N|e!#W?6*sxxo
zWPqpXtW|`N^PRw?6b?j*?Uw6;<wKkgC$-Gp3(vl~5#P^qJGb<pM@drbv^&4x6xg{U
zn4rA_zn*{2HxdTE;j}EgZbz6#_LEP9khakKLJ|CpMCjrBfvS}L=04~b`AWl{Qe%{Q
zqLH7${Z(7vzm|YjrR-5)Ajjko3YR{nzI(FMDY)n7A{mJ-igxu2$|8`(_W2i97Blaf
zPPS*OT&0;13C2^Z!A5&lZ>Hh03a7oH*}RCxS<+(Y&!X2H1x3=R0i~o_1U1UbmoicH
zY=`U8&ObLwdo+OTNL|Q-vn9%h1$Xn^Vp!yDFZ5!+hnBSx{N%>a7=H{{78qJoGMg_L
z^Umn%M4e#T2V;zr7-)AmQk%+vxnul=FBx#^#a`AtK<6;e!fkdHV5$^I+3jKMEGWkN
z|BHzj{Qyu2YAbbZ3Xu5OM!d{f>|S_P<f^Bwz^#ireC0c<eT5gri5ep5^X<nPtk_5<
z=)5wGi_oR@+FCnp4BLH4+{>@dGChWgd{&cyTdRByfd2XHb!<?>*}*`$iPfH(>~Vzr
zy2`w-@<$9U;xd&5&%8%fUz$KIUBV<Fm`2<p;eOMDCvbbd?0Ktg=$b3lLPa^n>Jnp%
z@kSyu4Fu)eA2D9L;%l63;F)k}75?evbtRYA8@$65x{cTX4APkcq0KiHn-g-udJ?q{
zu6A^5lOx`s3tv~8Kr*wBaZtf<i8FkD>?ta{Dw0_$h&H6^E{VfpYJDgN0w~*IV*U>%
z)7^KifV$;%mEcQ5w+(6{F6-Em`qgCNdBm*>Knq^}i2(*&bqh)kU82eC^=Wu<KI6}N
z(d&<!QP+LSyLsiHE#Zn~8Ha=h@an##BuDq|zCX3`uyTS|D0WqAr@PfubyRwm;G$M7
zX~CcU3^5EeW>M^c;gq=^txkURy>~>9(^A%Y>oymmh0m;Kc5`_Wrl@Zk&b19d9DUPq
zI%4};elMNcl|=_eg$|}g&eWg5=1qy<E8oiOPF5zivP2P%D2F>(vBkq0!9(1;+Ip4+
z1iGs2(*tk$2E85?cI1$0MLT7?Uqg^eNB9d9<pi1fXGyE8ryFpYA+L?u##&~b@~>qC
zEs(m!AZLIvy($27@B_QR^vzKwXsND)7L=Z`b#y6+CS3JToQU7`0+cI;^KpRx&b3Io
zb%WqDd!^Xl0skH7vUFygv^U~%R16>FtHk%FXhWxVKPE8F2E>&M)C_urdJCjt=0obw
z51qM%L!bzAw0K@!*4L|j29+;S2t0DiNpAYqxZ6;i=C)Y~yI4(eXSI(t48i)QkJdAS
zjgAang|D=DU$3~rS6bz~Tf2iuYi*d`sLS3*RlN@)1M+MUeq)}L{R!Zx&NrQ1^zTZJ
z@a&z9dh8@a_W0iT+Lt;mTIU#8NxRKgA7q+HNGzvC{|j{kGa2K%+nXCD2r%)oR^Oep
z_j47*&J*PFrLrFuN>I%iHkf<`SnsOR*p6+1{vqD`B6+>u4UZ=#-%XMrDEk`h3A1kL
z-+g+|-Ij@*&N_7njgBc!!O>9CW;K?$x4vN@3V-Emtu_|BTDw<`%Mk(|$HTb_H>N*=
zo)B;D5ZN~krF&gkwURUg*E=kn0hOK3+3qX^xLFaF&4@$c!swSI&o3{UaMXXhNbP(g
z$8#xj`mr8b4TkO|0fQlCj@kK*WC<V>FGIfwY!f^@H=WlMY5WFdGC1B?vbN{nDaP_;
z<E*s@**RpL?Kh~lX&<0XDC^d)PyU~n2?9%lRCM4A&vOh2ngSYu)2#uavs7S7j1dZ*
zq}6N0B{|`iPxh#D^22$h&e$$H^^<wMuHG59)g|0-H5-@g2_`<ooLXu>-{@29MHB;x
zJB~e=JKEmFYmvVE_$0vD3a`NCK2gdHoEXKh4m9CGYkc}kV7D#@LBn$cC=75x;O4L%
zxbJ02DgAN(R7)T7X57%d1pMzs4Sg(2{veg22_nB*lY+tmA<%Biq43qlsYN2o8swyz
z*|sNaSt;RSO8tQ=qWcjP-!e~AQ}4$k6>oP_NGBWwQjOtd4XyYMT85<Entq}S065bZ
zh*SGW!clqRmu<*44u+f(o*xgFgeED*=t_eFB}<hN>HFq4gdEP@fmf5%n5huPk_Hn`
zq|5|FERx3>WLNEK^Y7fT2{$scU1A?kj))5*V4;srDbS-`s4m&c#;x_reV0|t`47(x
z-r@2%Rd7^H*fO8Hc)!&;#&B9J(>2)*57x(GIvbYR`IaezXgCxVB=-6$<HYo8#b4yC
zOO}{1a%$5IUQtEIXikjP{i~z2g_7DWOhSwfDDrKL8p@PYK10R!^PmgXC6nGQ=0U_9
zzo76HelQG<_W;~kT;nxNiijC$)a5I+t*iOGk8j7!Pj_t`cP4iF%iYVuz4~jaa;rQE
zQ3I08Y%s<yBb7k-ovC&-S+<3q<Syz0(3+vQ;0XAedd7%k6C;n?z;NOB_9B7Caa>xZ
z;ZG2#E)ohFuo{QM!TlBY`fo#+^&5V&kUG|YtM8t|pa;Vs>zr<DN-}$!^*Ji*n}J6P
zNCMNT-6scp0=LK3lxkjpv|y#GC@FPxIJ)+Bj~Kqf3y#-!J&99%xThvUYAlAOp@3`k
z5OFXSQD+*Z2<|s|ZWEkkyx|WL_SiCY9vN5RBGxa44RJD&peWA-xvFh7)${4YUmPB=
z=Xb&POBwGYt~hTstX_Fvm5Z=#y-Q{3wR+^w0w3kV;|JJmjbu@!k=m2HC)~smJk!Qe
z%{M)bw-c9xd*)-3^XrmUC|UPcJ4(>Mvz<YM3=(5Y-YL}55LckiK|iYZRliD@hE77R
zvto9Rs57R$EUvrVowbPvTg@+JWqxnaWS@wv1QEBE9rsPc+X=S=WL%{#U8VO0Q2m0k
zS0F!gAcEar;$c)?R;k5n#cJv$5*#+A-0v^mb06?$X)Kv&&B!Qr-@i|(l(1q_9N>p&
zbA;YE$PUAKz2j;+@GRAszjIT5YG^v$od0x;{?pVBtf}6vBDK3_<~UFiqHtDhet!?R
z3A*9Ex_dfpuX2VuD!b+6s&wS!RIijU3%yWEShW7^4!wusB<7=>=l?Yd3_DbRfvAE`
zS9|R*+^I>LmqVbO>00qpUv0oZCR=GCRF6LyxWuyxRX8XHG)uTDg2tC}jY>SToE;MC
zL`vf;)kef#H5-RhpQIEZdokXY4co9w{^C*ThZ{iHM)GB#$~4`6>fQL&>$+-IscY`&
z>^5%0ikF{8+t|_SRU;a2G*QUp(qQr8IlM1ndN)X`?*Tjd+~)c?;;Iu7k6mg>MJM6t
zP$oYlkR@m1-IV9Jkfo>A<}zy)vDXjeyk0w}&;UCGnOgA7*KW3PGCF~HJ+hhq!ItY9
zKTWHMyJ5$as1zFZ{t`SyPefNcYm@#dgK6P8owxgNjgnhJGG0@f)hEtBSO9R7xAbId
zoV7XU)jeh-UiYNdk9oaT4PQ=E2)a^Oszyb}*HJ({l%g!C8feJG?oN;A_Px3H)n7zR
zy!&#q+_F~u*@-hJ2h=n+%K5-bOI!Aht+tx{oz1I#7#F@mJQI7o*>jKcZ!+B8s}$bP
zcY;N3e8cay_+Z1yjBP@`o~%%rIskxg<3@%Bc7?1bzIxW>cHM=&(>s-KOeCUD>`yD`
z)w1Jo%%*=miIW0tcjES*3w|MhBkXKx6cIt{5VSkE7s|LlBMm3?@CzH5W=WBBn2YD%
zb!m{_>VAbWJ(9LC`Yo2an(FznZeeZ7ZQ7jk>Yhrugm;BewiESaBxh`izbxTY(kVB~
z_SHu#Id_qw=9}$-A0#PUx4}kkK55RqDmxafLTx}Y5WHN4`(f$Ruk0KC5b9&hC8s4#
z!m%*D+Trb>8W%`y71dC9Xq@hQzgj?^-}#Bj->}(DH-q)0JWbjIcMNUM9=J2(lJA|d
z3m(1ddBphT^=#w&vQ6%>HsQf43l$pxr*>@X3f~LAjt3%sAD=VTPrge<J(IF86Bv)A
zO5t@{W?f0?I@%1XZ)efw9<k*<LWCwnOeGs+M|lHzy1q7Q(Es&izXIfNUw->il@aZ;
zeuELPkt0d}2s=eH`%zuOw>nDrNzNx9h($xBoY&yYqh-nXO~E8?1prD<F?vsOnOxNm
zN$q#bs%s$5Ky5gI;uA2y{lls#1eynJ^!D@K>sa#r!OVJTRrC2$yCK{>Jf`v0JJ#i#
zz()T+XxnaOQ?|89jI@c9EZlFxirxKgpO|X^yvjN_A}B$@$K!WrKm|pyP*c)gYGj4e
zs;f3-W|2?MIhm%Q!XpN<Z|I8rEm;EQ+e0ndLP(BP=VjLMg{#q6=~DYZ%<yqn;_jy6
zk%%8pUyjW5AHWWPO>k;x)KW59$O^Xv>(QqFl@uh%!s+q;h#-n+$%ax+e(_hNTvdcn
z?QBCo6m<<--@|Sy$tDL#KA^|VBqYyZ(NUbYgxV+?+2ij_#tjUzok!c~%8XIx4tb-|
z|7{A0wrIXz2WGjHY~G63zRSuz4P4k68LVLcvsPFIOvq&p*o`}W5epCkmY2UJ5u$P^
zk^uQ0M@iPPg?}><koQvOS>g|83Y{z|XO^GSX>w%-dpLz?-%?Pu9{s12M8kP&!aedC
zOklpo1H#`t3#6P5bjYWjNNEo%{k)*m#GwJi(tka~I?d;3jX%<E{kq1kFJ$g(NfK_O
z@W<_?@~Vx}CQe7G-}S8kz!twk;Uog)BHD#!R+E3U9<=(|j(a3|iQ4Tcjj?_x;7oX!
zBuam{gv?u1&}Jn;<J^#quRc#LouLU2z5Zxti$;Mc$Uab19pmq;Klu9))G*MQ8g6U-
zgdMkFHEj?J=soduBNr9<ZK+Hj(bv8Jz@IF>H(BDdvsr;SE9glClm9aRLfDp@#gb)w
z<96Jfw4V1wTFKwqOm1L^{e<OS1}-R_>?3&Kf40MBgilim&=zj(q)cQIZmpdIOtKtQ
zhM7jJ-w>*D;J2W3urLHgjinHM@q2(H_mJ1V^(EfVLZ|lWYfgo@PIm|hj6t=f^bj}(
zG2ax%ANc_w2@~iG(RCy-a5UjjO|1U^8YnT&hjxp_>IcTMQ(DCIU|<@=yvfA4$e{==
z0AP{N(LT7%a{yCq#|a^~5(rPs=KddM#Fw8&bX;AMjMn+Y@?{7(-&M(kM{e2x<NsE|
z$e>KF?LH{o(yg#r?Xa7R5CJ;|f)D=H<uqh3{?-B^7DRL$7qz*S3#Sn$Cva)pK-_UU
z^sv_3o$;W@>?OC=Fcp!oM_u>}zG3s9iE0!Hli5;X+rY(47(l+y0P+G;ZLm|Ejmi3v
zavJ}r^PKD2bv85u>xjsY$2=47AEla;s1J*HrUDu-W+^<(H>N^)n*Yo$IxQ@cqgmrU
zsmlU#3YSg1Qo7(Iz~>4!0#y)Xccz}Xa?WWSY`7r5Zs>Kfatd57f|Gci8)xhRKXU;C
zIM~^+H)yN$>UrnqbpY+}fSW7$$Gl`wRLJ@7sLh#8>(};!l$Rc?LTb&EP^Lu^YQOHj
zZisW~OXY)011dD&ni&j(khA-A#!<z6|Jy_TUj}t=vmgMOJJ#&}ervk63{pKLeIZEd
zc^q8=T&Z*wD0~XCe`VH3_wUce0M?=s{pt!$D>%6y?8aK2hRRKA{XG%R1!)U4JX-Cm
z^1b(P)s))92*~l9h)cGCpFBA261g2B@xFFwTuXP~1}=hEW=RBJ{^|%Lm<~Y0wXL0X
zt}=}j8cX*$lp`fQ16I*4JNBPdlmf8<ScwiIIp9@GA;@}Ku25r?J}vBd`76flY!`x#
z&(u9V)T3upvU0yPpydCl>$~G}{M+}H8zrM1l7<LPG*lW?S{k&sXiu%Xp{?>sNE&E|
z_MUfpN}Ag1u9UR9+k5DDUMU~X^ZdU5@On|#cwg^vp2v9{$2qz+17-V8AkaqL1j@Bg
z*(&&uWa?J=^yFI&oBi5a7i4V$NF<!|^1pi%<6S!W^+OC8Z(J**&(rWrC!R0bb7)nQ
zvxP>|oirzB!b{2j`l=G7*|kKv{n2r}g;05pGS*ISRnai#61wm(SV?(afq|3j2l$C7
z-A|G3AQ(`6BBuL$??y1vJA_`c8B(83dT(=cN@^_TNlRbpf3AJ-@UaX?McHZjchgfr
z2F!=VW009gEl>Bfb!u1&V1Z$f!gUV|#s8_UbRCQOHGGt%Gs|T{WcHp#T|$^#!eOXT
z(X`Q-P_iN!-Jd;;f^RXG1+)0WXS{MKN^Apr!4F~R(OWjH$*3IS#>Ntm{o%mwVa1p<
zBcR;e%q$1I7%I8@Z55(cwidr_%3Ic@#|xU3EO%ae1WPpY$0v?|r`Jt9Uu~PTzVh0B
zv++sWJc^#oIE}@w|IRA+D)I0CRN{pu6F!>t<{1A{D^c&#1Z$rDuK0<2dLQq+%o14X
zt{UTAZdWK_>Sj`Ro+TJqQ@sy-;Jpnx;TYbSRimHU&iGZE`#c#bYf7pQY62``b@mfT
z?GzZ&Ak!b8eYqcgCa?rvg3m?&S(sfWp;gJW(c_(|VRHQIKLcfKp2YuENB?W-M1Mdf
z97Be&pX94=|8#hNxp7~!U%yeWr@#GGLEDD_9e*#!jt*%3x*PP}TR+ZJ`ajv9@TBcb
zc<crd&UPkUB~M7EZjTMJl4n1!^@F&8CdsJi5{vzl5u331{~=yp0ODoP@$f>f)jA&!
zKVJ(8=3}YB5Q`Q}2u8)O!qyEn5^I8-r~|(#c*2u}s7Vj15{p=|Q&K;iu4?k>)U;`t
z|I0Vr8#I~=uSao}&BY0gO+9wK+zLjfP9iZhI)$-oaLL{Meg8D@7asg+VUvkvv~KkK
zevv;cy>{ktAz6>{#g~IJi{mXTUWD>De}9VTGcbP_3enynL{*wbJ#TIBj;Ir{Qqhjy
zt}o>ajqK+OhA*dhg8C)YH;~6re0@Mk=`<dbp@<Dbo@Y$#Cfs^;t;K17Dowt0Uu`xC
zy$wXd(eW#A+;T)N<(vmF*#(sxznz1E?}1zh3M-e$b4NujW3*UYhb6l{HnHrN@_vU0
zyAleCcfv;6KPPMG@G%#!h8`C&Jk%6R?N%7O1vgzk(E5isKk4Tlm?PVM=ZA94l$%AU
zh%$;vx9FO}mj58`L&Zn+{bxhuxw2R%Ig3T{SH|j3FPySWbcJ*nu-sh;Xp*oQS<n#(
zb?v&^Hw)z@zGs$AO@fA)+E=UsW`^gJS@=CMb%(u1_hZll9wQ_K;p{y8_FW^k4>_|U
zM%vQ~+Ucm&*&2GAObm*;4bW2)f){cvCy0v^tEH><BQ$qmd{psQyOArl(l+y9e)b;z
z{^zyyV;vypcbGE*4TroNY8;85JS0AEOdOSMFc@3nV>_KKjJ6v8QOtz7A(&M!feAw5
z1zO?IKkV&olCOS!;i|!F%j69FR8CgYq<mp%1r=%UOg1c4G=S}2DQ56{EQIR_SzNj|
zoL#+o49o61icjXRA9~oSkl>D+lAMPf`Zxd7V}zIvjs>Gzbeh&tcBamqX7j0RI3mnk
z6gR%Blc#8!M)460sctVFMJ`o^1`4$&QIM|(c9y?E5fvM^#>#DU#HuaHV|*1GJM4M%
zquMAosYZ3bL35vj`&`v3RH;J;%c5@S)1lUy#i^7}FCbVbt!8_1v(&e@bZ)7XeviI;
zl`I-~%h8>LUQt3VDSkt(qv&kW7n4lU@hthulZUyf@&iv__x=9aOnMeb+<&nH&?E$J
z1v_u<WQ{dciZu>rG$ciMEKW`)5^DEJEh$$j({wb&zFdiwnkxn8E%eU-@m`A}oI!k~
zQxdCoalT$xoNR;%kOpmBPhU5<TkDL(t-As8vvMkfC?U1>{x76fVrm@8Z`?npMO7tt
z@?H(iNi}IL2C|ekBCCO85%$P7vp^Z{Ou*6K>g~+e&|+b$wzzK4Fjo(LVp5~$Nuk11
z9*11FRcz44(ME&sd1b7dw2F{XYE<4}bsAZrAUPQ(vg|4=y+(DMo#e~GZP37*Z*Q(*
zwCwvk5XBJxc=Xe0IHz*;>qBxM?6io}_9P{z^)f^f?0xkTQUalG{n4En%9OX*8fpw5
z@y|6~q+ohYh6zoc5-2J#KJME~F{@Wh5qD><bm!M5_k(hG=h>%pbCs(=PphvHV-B6<
z(5*xXEe~}+^3P?8Vkz|^8)4j&?X(~9;8+#)i5}z0rqR~TP;16c`*k&3TYRZfM<B73
zR4Y4u<)51+)ny5B1*KN8o7VR?Le5ka0o`*79DS}gAWT6y!SzpS;V&{D)%1cq$PCkG
z?RT7-yWz`AYQx1bL!pMf+?oZ%u($0))xN%8)_dod?NG&Yx|F1gy>zWIN0eLlT5&GB
zX_Sv8zB84ZQ5<!9N*F6qUaLwh7hg=!gy83Nw_iPa$0ObLu>cWgo{OJO-W<&T9^Sny
z7D7-`gAsKODpQy!eQjGBduMJ1hs9LOnD|k$X1Q)}<kFS(nk4st$Bub&O4jqJMSi1Z
zI-%`br|mfO2}|f?-W*H`G)$R)YNLOns_<I)l%AXH)>`s*u0y~Pp6p8bdfV?!x@c{!
z)pM$Y(=;q?IMb%do(s4u7KW_7CoHb*$hMD;O&8kD4#`}*8%IUK%*EwtKUnU;Z9mg@
z^Bpj>+Bl!(cGfkD)y3y%w)B0MI91Qw(29Md*PN`vPUK0~!uQ6^Ewt{0XZdG-8FSf3
z8Y-%~hk(w<znN2%6!LQoi9XJpIWri3U`*SECu=5I%d%gktU`G_({rMunKk1aGws9v
zuC=Gjs>X8pOyycpRGF__tSa+9JnZUVx<&Iu=!)tC5l~VpDj~)$LYvO(BX3=Jo$#x^
zP+OWUY)NgI9IXN~iNUr=w_lF5lSnv{r<QHd0}&7FbsD17eSy~jd~=f51WHb~PLcOq
zTfE&dGNo9^&QfBTNK$;8<sJy;RyT}~k`_Y%^WlSx0yPp`whezJkIA|B@eX41H$<x&
zXSh;l6V3Ts=q7OzPaQboL3Hvg+Sd(8vvtX%vKJrn7}|69-`|o79_+~RQjq1X{<Rb@
zg!t`^j!ir-Ij6wwvSHh%snx?2<(xH9!$i*Gy5&F(jszdn_M;ScIGP=-m`SEkX`<#a
zG`{Krsq{j)isc&+g{2j0@)~c;1rM?wf3N!Ih>_PpF<O^&2NT;#i%pXw2jA}<{eXu7
ziUT(E4SM-Y)*VwvyOS=a5_$5Zo)<6LKNWx!9+2OWbC@JSIKiYfha5vup>Y?5q^5gE
z?^Qe@7y4nv^xpB$Y50C-R1p$|%w1i9tq}7{9eHH{2WP~E@|E2!L{gY1@_l6eplAXW
z2GVH@f%mr3%djg>4t<>8zg|1FN6OdZ7aX@O$!&Wnh2!5Sy>i9L#xUnQuGa<rIP{ke
z28o2|A*MNHm&K`2+q_@Cy$R(z_vgD~6&*^Tcbmyc>#235TH}x%X*a_+vuX7Bq|`is
z6aS%R;PjYGV1L~g+<p8YlXauoQ4u22EY=Z#Me2^c9^F0r;cexgp%~E-4Z-4FtAbY8
zt~b5#iU@3?aviUCPnIh2LKu)?SM{gB<*wAjg_P9(Pioh4EznOb$0$I{dA=IGHuMbp
z?&_my*b%My1Z*z{Z;H<;zvANB6DUo-Jg_a}E<AX%DD^pZ#CPab+}q~(lQ-ww5tqV?
za*<}>k`vhvYHwsIQVNs;f>>N0++4D?P>+k+*@_ncvq;v33#UB>W!|vq@4v?Zk9<Oh
zmdT@bF}(9r?Vko@V%B+!bpunm-m-J7TI<HQYLR&FTsLgWX#xBO*;Ae#KAt78+SdlY
zdli)|t}a8B-jKV6sX-wr)$)63UdtWo^))Ft5}75#3Z=;C_QZt;z{Zgv97<#Q6jFUx
z?sn&e{3%Wn{wYqb^qR774%6-!A@t0Cn{NUuuq=B(@A>iPb1#q?K8PdzJ&nsjrh5=y
zpX70*I+GPEMCd}#y3F4{7?-k~Xa8mn#O{UpJzDoqoRNNNZs!8NJ-E)fHq9b7hXPJZ
z|Ge3+cm2DNZldtVu({*nOt)>62S2A5yd@%<E{|39064CwRf|`7sddQ<QpT}I7u+cj
z_oF`BHW_UKImp1{?!JHcJ1etfD`3F$#4x-YPVvgxzcg@sVm>9WN8z2I@%=iSoKgNt
zpkGO8P3S@S0c0atxMwrkaJ72myft%ZUB-9UO*Qa&G>0rG8>)0Qk?@D6i9Y0B`ZpAQ
zQ%pb0xG&IwG&Vfr<;|Rn>(~bF`X^|u;_4s^G4?(BbT>kuu6ZM7V*|#Pcb<Syz(pOH
z^$YkI(8ESL{2;`_!@H=*4iFayGsp<+FF0WknP`75^t@IOOc^8H=H|C{sf@J0b-)%Q
zIkfZNxz?WwUj3g6o;ZzNkW3hNqfoNSROnO@F!(oeq)Ivp2UE$#C-<Nh2u*<$s)|05
zp4?>IEqqQ>D4ypQwqqE+T^Up?d%;+8_E2gZtLW+dy4)z@yScCi4ydWFC(>QrKWJbq
z1XJ%Lg~5QhbI6R)l5($uJUx^?x}b3K1zC)TMhbpjlJp{=N{~#T_xHZZSHjWf_+!G3
zi>%wT@*8$t@KV-$CWb!J#@e55;K|dk6|=lM67nZJc8af;g`53^XHE(hHc}%=Ha@nY
z&*eR;9b0*$O^f0$QRHhzk5HD)U)1OFK9;&Zr^#=T!vRq$rB<-@GC})sk8z)DBR&zm
zqUI;ATH|V;gJ<gIM`D+bSA?~CeC$E)R!7gV+IVt0G?S-iPU&RU{Ik1xU6Ent^&xE8
zWjpKdt+|;_!gdpj!e4g)$RlQT?QqEU2p82C6T|xJ9flK7F5B0R0b=RYy```!U}%VQ
z&3rj9r&=_u(uT|Sry5<fDBPyQuI7|1a0B~ZxQ^h)t+0}NjlTDooVeUDr0BX!T&8TE
znA0bYLHv3i)g8x2Aki+>XHr-BzDP??ZeTNI^F%w(BZW<6ZI=uDW3K{JG*&HS0#aaa
zN<2?&WRVtSFbKk|VqD>m>246J@?~uO&XV4et~u9^<?U>UuTK!omR<eUscN752FE+r
zl$qCCt|T2t0_r&1P+_s7k4d|t8t#1HetoLZPt!*EwFHtiKKrvZi=v#CCUp_=O(|yQ
z6?(zaKl7Jq>e&k;RaLH5?&g_~^xc}S>+m9P=Zxy}4l8Gs?clSTdfw<2l8;N0+=rms
zB;A!o=;-kg(pD+g!y{qNTb8)*-->m01|AA%=r^X!^}DX7V+G^4IATH(Wpu&~k7nzK
zJXB8n8KY(81^~^sY8n5X_<CH#f2qUStHd<$U~GC>S|k5K0M6<s2iAG~;>!GysP53I
zR13qc8Lzm8lv~kK1kEo_kk0++G^h4%S+wU$tq{YoIaQG|^q9+kSz%L20&p|&oZuNG
zV=A96n{C1jmpO*?a}AxF>WGgADxa_Rv~1ZVo<@wgJ^zkeyc$sbgb%^tM}RjLZx^Y-
zq%G1#kKxQdKOY)3`hYip+8|!QmQx@{5i+sFbEQs3H(emY>1Bv!x_Y*>T9SK;Hhul_
zF%==9fzstbn!ElN+R#jzHeN3Ja~taVF!@cq-N~Xn^ipnP#xwOCHC$}19I>f2foYy?
zMRfb~4wPhNyvqhVDOv)r%rIB^u|ZU9*$CH4f!BP}3OyuX*qw3Eeu3MP3m{41=-2LX
z><(9_2Kvg%JXoou2ESNPbw*U$p)8Lcd3g~g&9V#~zxUAHB3!GGy1%x-^ir7r_5KXy
zyZT?*G$_P%;U{v1%l)(joEliZ3b?7n_{lb`F!Z)=0%6O3S}Hdj$-ur4-rU^L&bj)u
zrnf9|4dY@QXg8f?$d)-fgL(9FHFO51Z6l$?v`=XJgMq-Q&Ltv0k88Xg)Qk_3$2r;m
z(3B^Agf9kWQa42!#Gl~*F1S5@eWw9xk;~j#7>iRm=^uak2(yxX_0{TsH~Kksy?Ghr
z%d#k{Zo$&>l@IylZ0Gw&WS1eh=%^AOhRw-|ZkGi2b2ictqv;SIRr&ab<*S_Q7Q6#a
zD>G^*`{Vs#>XP8e=zJA)YH)NaQMF^}f@sRnG*l!8Cze^TD*NeK$fSxE(SV}=Swt>A
z=~+(Xwhb4W`|)uHXxCcnKgIIuW4<T*m9|O3AaLQwkfpP+F0?COu~mv&20nUcz{h^L
zi40k@b8+IZ#cE`~+^?c?^w#_ey2Ive?^}$jkgux(Xarwh#9tWnG4Rl^y{;xtkG;PI
zgS(gahoJ<2ePeP>n~@nCFz8nqH>i;j>_a$Hokf=Ez0({eU`o&{NykE5WTD{bAmSb3
zchW}JIWKlgsdP}rQQTM%0S!2b*T#mkx5$0Q&N<f}Hp__H-k>eZ5O{Sq#3!!p4m|s9
z6n@9~0F5E}j#xXu9Dd8soAps|5>ypV#clsMiT;6cwV-X>>_(VMMWf#HcXcK3x%F?;
zjiACibIZ5a<F9)aP`6ysjeqwqTF^_EF<2$HP3|+*v=+f-Ynt&W?Z)S(o#Dhz!|H+D
zmRnAEz(SOwdmQWizPY4`E8g{KcsG|fFaL_IN?NXS?8U<sVWBY}z)(S$mDFJ*QDsr#
zROedjB=^KDRgbn%e=KE@R1~~jKEaJt>I4=hCzn&cE%?|Ps_wcOfl76&b^f3<bA>`W
z2L-;zP|!)F7Z%aD@OV?d4Yy_)slWJrvpH|OVyD|u`>dr-|73mYC=*iW5{?v>ZKw;R
zzJYhvx9782M?m^b7iNNirI)8!5k{}<gCQm&+zT!CoXbq#^==V&zmpcnimgT(yQs{B
zEkw2e1QpGSpBd|TGIg;<nd3z&PD_#46XRE|zzWAo6iWMvMIMcy0~C$fzhO-ds^k*-
zM_8Vh?fodI3kD6s(IO~(qJ}57B2-dKSAuF(bnkPY8#wWjf*O|41wvxAdekqDd2NIf
z(~Yo_qAEE?s^{}+U%xads9yq)bqP;*(bPJnOY}+2Jx;xTQ3J2DWpqJ{^Su4n@Q@6y
zx#ckk^jJ}pE`{9)>4<yX>$`f~)kn{?bE2XuGg_0F<6?<&$aZBO=46i_b{fi`^6k}3
z(9sF(e#zBOH7R{}1io)@)t!&9#Bzw=ZMUA~e^{TnvN|EBv6HKusUyJGv?5^cpdKp6
z4?khTIOt^_Jwa66b}D>rc^(v9g^8smdiM;%h>P_-88nngqwf(XnBcdiyOzJ|S>X)Z
z96gfPv6{yrqr2A2!<{zC-3I#$9Sv%0=@3!)c^=zYnHWDK1FEqpqe8WJCpc1bNGq^M
zPwfhZZG*~xcuSl0{ZnuDqopj9J%p>*V+{A`?ajw|saap@XjtFi=rYdYGj>tn#S0w7
ztWkHhTg}$mF|*mujt)PPl`9zFLZyGd?(o!`(*52(767RSF{p)gZ<r(pnvX`fVS-h3
zYS~=I&+-pWN2wB{<`so6!<^|Sn-eFK(I6&dvSxmmoJJ0t8u>}>Ct<R#@bqf<t6Hnk
zG)4WV5lW8v9EKYva^BWT*PGO!Rv4s>^MK|A7HCgXdZkv2uk!^*S~UDASSPuI-as1n
zVLLqo;aecQn-!tOnt|-1N%vn$&3vKqNR?WG7cw`ldY@Ztoc*elz8X|tLeHruL8Wrf
z>Y^~TTw`bT70vRp0&YlyHk)E|HCw08EriDQS7~Q+`A}|hjSnQEMX1}7n)L(jadeLS
zI2K+847cZJB(6|B;qlCsr_HY)qvP1c4fGk9E5N1EZc=7M{(GF!quD%tf{<-VPWN#P
zRT<meR&;LMN*T~bz|qw#KFYNamsxXeH{$|QTtF}02k;~iUM6YI@vc8nRL3Ux;Dbx)
zPaEu55N+>>f23t{dbav97q<`PJrpb&Zxp9Xh2KCqBYNA`hY^<|S8()JP}e75aCB+f
zyo78+9bM0g>Bc*9_5qls=sI$KJ><bjwzef%zhzHFM5Xy4Z%NnwfM(F>fTB6}yW_G8
zzZ14?n!QWtXFP|d!?)AuZuS!yJ{DY#H&T18qIHQA4Dn@u6h3k`y2a>p;SSMfi`TCs
z3`Vcg#3Uc_&|F6lsnzMUoK~q7oTVGKQ_Ya(34k8S@d1Ek6A}{$x%C0c#j0r=s4vJ@
zd2KN-vtcWM(iI)slVzy&@}<R4*>x1KZ3x@W*9<tXvtk{v=^K}iiJ*Iuu8U>C9&x~9
zg^ZxlSF0XT(pCO6SCI+bF_oQjg`5H@bV0?=(p3{t4nNsm?plQKGC>Ug*7vKO%{wMU
z8!xU+tx$ATvxhgkd?6h0m0g<&qbR4PnSgo9{zB{UuX@Jl%f|x!H&Y|ZR@2RDKg6zl
zBtvI2|3crIxO_}MM3Nf`-6I(2{L_vms3z347PWsG#C0UAWRoDIQWx<25ww_WPegbf
z6K(NWdLhS(Yc@wR85<r{S7Sq6G9*J5i&Mi5d6<l-zt3$x$;Ld6>1ln&qWQSgc(Tg8
zEp0Sgesq2?tL<X1PTG@h<?)XGQkzQRDU1@&W`AngQ=Ru)aUt(#5h*s-qUd;<{=${F
zrdFlk8PraDX0+k`!6`2_zmjJ(t6`!R<7bO`zgZ+ScMMe_B4@oqY;pfiN6xKA!U6D+
zZwX;hYke_a=}nZXQ|2ltt8h*g(R)5?)KDUmaH36!UFgE1&8crXzs8||Va)n>)R^bL
z$+2dd%IPe57|XdXKsiy+a3&7jzZ8gT8FOnWo%VXvx*4!C#YmaU|M<{YmBdn^AeW#2
zv}{~aM0H2!mQY}A_b16fv$eS)ZtI^CVOJmBSv<xoeUhXbSkkGFPxGTw<T@m8>23k$
z;OyLI$#vP`EvtrsA0=0R#>eb#yn}}w(1@rQm_pM?6M$_R4fQH_w`|6S!M1@N4vocN
zma*K(Y@c5$YRzK@>Sc}Rik#atn!8fQ>{(SO%uH3c1+j)d?<vixNuYIJOl6lsX4`X!
zCrZC29F?8_F64?h&*@pP%b$Kru@>12iLiNl!o7^N15<HNAHOhdGNn$)5C4bDo2}_t
z^?X2otu2K@@y)sNgWRT_EMef<4*XfixMWV7u_o3ggTe*ot7lokfvF4!s#`&wCB4*3
z=5;}r1qEj?;HU(rB3se)L;LS87{g`YqhX;4ZGhPOU>u)<eu#kT*OzOwH2Omy!Wy@N
zd}a)oo%=mqYt*Vt+ER2=<0I&r8s~APx~UJNb&!OuRWh0;)q)<KYu*%yO&Z797G5zf
zZGiH26z7C?BGA3xpVdal-ivp|Lc-s;t=H>J9}!yfkXs-B=x^4cq_R9ES<1zz=AaVn
z0_`(G`=)_=ngL)(mn=Vy)9t*5O71f!dU-<pTPN-FroGIX4Rgry6teK`b2TCc1v<^V
zQ?<wn3%uQSlUfOW56ZSvKZooh7Hk~Ij%l?t{u*lxGdy_YL_>|_8rv*A-ojDfxUQ@}
zBVy4m?!I{U-Gd@rUKq`j>C8AL^AVyKR<ZP7vXbHwz&UTx9)1!H#ONurudnHq+PKf)
zd&m+SJ!w0KT~9n(A!Yb}xv!RG{8905JZ*&ll_o9ehov0hKbe`F*HbnVFxeJAQFP}d
zp=!p1TiG|OeRAHPeRHpPbU_>7tzQ^2#2st+%ggNb#WC^POmCQQk3Ndr+Q%Lg={@)?
z?;C9x6K01Ss_+C!qL?f+7T=!3V}>d?Gg1X-I}znHd0E3{xnq0wyr^+<YF=pV^<wB%
zuy&aw^vwKp_P0B5S%QIX`TNAMZ~f+nBoKQ@OcyqXA87K^G6bs|7I0`uFm<9UhZ*<Q
zpVe7HSTO6s2#_FhpfyJ_UEGKX(6krjI!)g9&YwbA*7RiR2a`oR{(ef2P)1^(fvV(!
z;!-!=i<b3m$!nKhF!#SzSc(g4pUEFSL0e=yaeqe@;TJe<0_2<nXH9Q9h_2TV)`6w-
zF!i;?deAOM>8Q90EbC6C+I^Q4<O>0Y1Iww)d!<MDT$GXOand;(vxvFnw$qj63|PPZ
z=7qe1o41ZlT!}yRaVDS_>ex7>VGM{LnmPYleclx|IwM8L!^!zJ(&_B`a{=*&%d!B<
z$O<egPW5ERbNkvEYn!HsDg5nDHjN684nCs7!1;JeQ1OCxUm=Az+uZ!s*yQ~C^{@D6
zjJkB(N+eSz-;dmj^d)0bpKmnYuzG$;;3%9vdOLn@PRg@u^TXzIgBADgr_g)yD2HEW
zdl846#RxR~`Y3)=)Rbm^%m`G8@*6*!ljcPcgde?mf!cSF)z@2McPb~S;4e|*cgPAm
zDL>>9a;XqgtV~0*ndhFYz*5q*?te~q;b4+xTOWCzByZ~_p91R6YXig7Qd@;9K34I=
zLw1T&Gf^k@ZwtPD40QLX3kyGTIFYNh<|SWC-EnYe<Fn4$Wm9nxM<0h%zl->FzEWdT
z;8aAq?1B14)21e$nANSiR~NMG{;GHWo=tWVbUD*YhsJsupZ7HP#I)rdO;tOkQpjG@
zx|!rPD8o*pzE6z;+~~FNyVW@mtn^a#RL6`gP=Mc0!G!FcBK6ii5u!E3Vs<DaMCR&o
zia_GCPukhBq2)Fz@{4BhD#h#jj4l|(1UfuOC(LE1H#m&3Dx||2-hP!;8oGmud$v?C
z%6wwNKe)$QmLt3FUgRH+78}1-;ARSLKlZ*eWz$QtT!p4QcjnNnZYFS9btd7XyDKD!
zZZQ6;7ip?&Y9WUuvt<m<+bV9t_;`fmYMuI_Pd1Qx+4LE4?Jp)fk!VNp*heM5+Mjn7
zJJ~pLmfT7%kmvbyS?5#_n6Y8(pZtI5Sz4q7#m|pNjB#`N_LdWMaj0q7#l7R+!`$U1
z-0gmU{ge2u7*g<?G#^(MVRsJ9ZEK{g2%DMz_#2Uf;pb$MUsOgnSs2|KFPv<*B;tSW
zfBS7?;*Yqkd(Pw`fv=va1gZX+C7|26B`kD?e*5&~VJ;^1sy>BN3weHW3?-y4(n%+7
z7E1=i_Dx<Cp4$6`%NJfRj~f)%aFZ5{il#wXx95KI<&ju}^A2Jjhknmt`FPYgdIR|C
zU+BJBcvme2n3!Dk#P}XE-QT~2qbCW!Rsl{3CPm6yK1~(WeE#V~B?M^QJLevNi-2t0
zGbR7n#={H_*v}#lLk`UD|Dxh?JYQ9?Po56Ngnc&e?0iano82=TD4<%wf8$KRYzRL<
zaT_2cuhYJ2OeR_h6S=-v-C*0|r;XrKNqjbJuTTK9iH&|xpfJs#KVcL<SuvsTKIELk
zv^V~^7aqX(B_+6idThXMC-`W@SJ@m9LaJB03LIqVfUtQ9tf(ZsgrPRs#X@Ev!gPoE
zp@tJg?@O;}SoddTG#jB8C12*$7FgKCWAO9HI*jl1j{wng&ImY*`@1ioXW@ojCA=-z
zpFJ|YdB1U}U3{yZ7_SiV>x(wS4|t~1b|&XuC)!jNRb)T5ZilbxZ)s#u6l9QB-_~Gp
zp5|ow(<-4q7j+lbC%7@6NE`9b=QRCmJ!81SW}b5I%=k@D=4DDZ0SAX+Ln+_=(M8f7
z*`*}UW?v2Okn9VtM7ZuYm!XL#B6D$;4Msp=cwium>{0R<6r)A%jZC1N8Z;1T8&W;X
zjEz4F^YlNg6ol|M)O3BZ9LHS7m>+J2wyuM4X)M3RWOok3WhR4!WAcNKbjfKvKKI?(
zxv7nrKW`~08;Wes2LSr0V-WsrJDNZPssZ(jOR$Z>=&7Ks-cc0kS`>=ZXJ}0%U9U!w
z{3p+Hlb~JHB3>)vx!r~`vqivo$N8_tm&~(9hLi-^efT3HEv*0KXS*X0()#hY9a(Vo
z(9*%rDJLTakK6p<Q3Qvw(o?Mwg|b}wD9fa0{$H3x-0$xd_mu9I^IAptaQUilx2lhe
zS`7Yh9w#L)r0cW|R;d;Z!E&Nztw{oY6L0Bu7eg@V++=6gL!Q8hdg{XF#MWj<^g$}V
zTx!$8s5AFsIqQtUXz;8Q0-^8ChK}2GL4$Ur?Y<i6=D<1D)uVcLHC9D>mA@655Q!&b
z%FyG1GI8(N=D>5bzF<89HXiw`0a`<XU({$kd1OO_0PKX6!0xVlnh2mo;cM+V-W+2E
z!Q-i3S}_A)BjL$Il0yEk8`qoj#G{sq^{Sm!)aol=a=oTG3Q83}=z%Qp5><P}mHkH}
z9zW*M?C20{Ez;OwXM(w}YuMY@fn{(gazZ758<xAU3u$y0{B?wIeB#(TZQ$$pF5iLC
zJm&6dX>w-mHX3s79vX?7s;TJteXa{KrAY7xs+if+MM1}*IWCrp0l4>ayQVYC1Zjs@
zN&StJi~kj$-+Pr(P;>4{H$)?SW)Ps8acAD1?Z6GC5~Gs#hS89eXB#>Tb|F0lVH^_a
z2XoBEK~|J{c`4u!T6yV9u=efQ-v3JzdFTsdNl&h_+)B}hE*lsSTg4!9$bAQ=1Nc`-
zqE8{?D}$<>K5o(!Hf5=}81vaO(ZPm6bv{DcK9*A{N+az5u!|bKFMR|$YGs#gjj*pg
zrQM3Q_3?U0QcUO(`)~F6HGxNS?YFyMe6^V#GL!Rl^nGC7=WGt|aW=I~#I%Q?FU-Kk
z3QprnL3sX&ky~?U0%`<u`n{^*T+gVxmd(zd_jp^Z=kZg`cb`h?s95>-sTzW%!1d32
zP~lmuWikTsK8ED{oggVG&Jz`3m$Z+<1_sRrgAtBQ!aaNqi-Opfd={TxZmbhf+r82t
zza#x7FImBk>S6F(G>AvnFA+X~+T3&H$i3LpJi@N?vXtb2=-kC`@6PORbne0|C`LYU
z|8uyprVz3(@5Sw?&<{ZXxB`wkBOf7EeDu6toIJG;a<4p)m{C+Ke*yiu&-Gjw?7f!?
zWr+SAM1GG)s&`CRkJ0e8V|fM~J_>9vwYh3pl2%!kEQh!ZQ-6Q0Hh-u>!|JCZfrrU?
z;U{|!fn(y(`$~-cJ2pf@ZVj_cZ}xGpvCZtsHr%u;F`h|7S&N8tNqkF7R1z@!Yki8k
z=jDWz?}vLxArA(xY-@##N!AQ)6Y6SoTSzwGoBU9)BH;i?X{%pB`!jH#>YqkB+g19u
zdiMblsdu{TCQy_W-ZdarzrR<ryD$xjMDSqApeNCm$V)rQOz`nt(^<L1rA+I#l^Fq8
zf-9S^Ys(`@*<!Ouj(EHxen7pyrQW|o$K|;SUA-{Nv){j?`|VUTtg0z+(N9lg0YkNO
z$&aSGL1<(AyoOzelHbS7{SD+F#M+Zi0CoSo!*{oxZ3F*80>I0^SJvo?c5`*;BGur@
zDgc2@kq9<Olwj{ck!5R$N&=?U+7G|D^}K4obEYxRPE-8~efCANY<#|!Dat6f=Ywwx
zm5y^}zjZz9uU8dT!(V!!)nV931#m`9{vA&(ndl_c>|n)HnMHHIw?J|JvQ$sA&_{_6
zX2}5{?n&pUOHYUXhj~!<#v+YJ#<orXGg{7V&bRo2>;t4JBP6Qa^G*rnW?;^gm*(_Y
zT3~(_OqV85MUfkQ6fQX6n5F{qqjk^j!emMk-wm{4$K&RAM~M@zRA80ej+{7a1POAZ
zp|P16r;LrNX=?6*RcflyjOAtBK6Te0`(p(Mm&r3>6V&V-YI8l^Q@!=<Wz!Q=6GVWG
zWv>1YXGW%t-k>p5U&FE_w_#G-h~}@aJdF%@hm9|i&UeWvydD&o|4c?<9@;y%HtZjE
zPCSkv7CfHoR=OXZ+@aGG$i^TZSPyqc%!8abdiT)&!T9=0MY1tre7N=V?Fl)zEa=wP
z@U4yFm_VEvSV+ee6lNixtj%BU(hMZ~i{GZS2K<$b!T=E9-FZrZNW7mvG-mR!c02ni
zqPo)#9r1Odpq0;qANUVAXm)U^R%Fw8NH8T#NZNogOY1+pl})<PdKO{jKn5R;AWbjb
zFiAem%Z7O#S4D`3w0H2Bw$G+m%vs<ZT8EBKJ{G}MwO-`ABW(l8e>S5xSmj+#zxv_P
zGUR;f*VqH*$zaNx4{R@_tZb=P&q4>SEq|qPD}#{^;k4WMBMWSOKFfK8n$RXMu3*w>
z^6NfcSbLm7H--7Ey6vK2?F-Qm8DW2ccB-C>VP^MNxb-vzJrEf$qeGXPVFdSe)2Pw>
zzKb8wOeRsKU`dFZDVoiT+WN_a1_$q)qGQ}fvcgQqktU+{Um_ew-^V>#0h(aj&A{v>
zYP=0rJesJFVkh|Des()V(4I4B{tce5JShx&rM%c6+34hKs5h}q4X35nw}22s75j8I
zX!XVI>t)3DMAwe*-NI95Z&ALo(v8VvtRz!}9?1P1$B3k}yn=#D`q9|;aiPl~fo}}4
z(X=3wdq%qY-OX+1*yc=s5f(NTOQ)alafi?e9NY`2QfQ8e-Iz)TC06%tC&@{bG83Rg
z%o}@Kp8ZH<tms-2cPKsb2M2KdZgv1raYV~7fBkD;9kg&XTN-cqMH<%BjF1B~kKQUk
z^;Q-2U7He!VzZYdAJ23qAri2j1xkT`gL6X7%KTGi$FrF!|7-)J;FPo)d8?@KxkWmH
zPzH6i;rza%@7{fY32APclIcSsG%OhRV=C(%!rA+|)$&N$4{!XG3!IuyBCJ5R5SFG*
zK2|Yv)1y;LqGYgSdj%`~OV!)Uvq{rW=&MtRK_YE(KKLU}ca{Ch)q?%%V)`q#M$F-t
zYpuu=+7f=IBx`m}F)XM2g2_8+Di~=o-QNBTgaW69^6yK$T;?Pl%n$ENn9#euS~-4r
z_NPf=*&Ad&ZjSPlO+=Vhm(YSfB<c;KVdh_I7Qvl#TYDPSs}O#Y|1^FgRWTq+m)0Lq
zgi@VPf7g_7v}L08rG+c=i?$6=Crr^g{0dHYu6}jn2f-6yt>DUbw$tCJ)-g7p8_=gz
zTkXlAo$^a0_L60h!c}bzO3}yWbxKMT;k~M_eW7?U@G7s}Ph(m>Tcc~i?YfBz-6n<a
z<D!EnOCu>`FQ42<Be$3FUW2x)+E<vZ2#H~6%>5+A-BNCA>$1j*ifJr&JW&^S?Bd7d
zZLn7qne|-T885l?J)GAj<#CcMxz1S=S-#E3S1G1*NSm*!5pCLz-I0H|`oWJa3sieO
zKo{*VsO;vG6XwC2yu+!b-=>)0e4CoNaO^|<>KJ#gim4=+$zwM%k2bb!kFdK<)YyRJ
zLfJt)mW^<V#E_3}?O1WJSTyT^K80``CCZa7Lkrzg{rz6*XJ`?L)qaBG!Wx8`zo6A5
zAqi1uD7WJ6X$k5Mrfahgn^7`0N-!pT&C=l6dOj0@*Tc>pKP2f|R|%)z=*OSi9ab7X
zGmb4mKF~9==$hIU;pov-v`fD9wrX{;<Ko@7q&bVmEt;9MJ8Ly@mq|mvf{|y9$^kc=
zQp=gy-YMe|r%wgi8y{Lr9gzkvk%Y`AJ>$j{2al*+>AGi<^aTIx+ra)qwv}67&-=f#
z2yeZ)Gp?3ly}+npWB!)SweTKJTxjFoFWw@jqrOf8fR8?zucpeKv@~cNu3tL#bFqp4
z8xn?W%^raPxF8ihdMKTZYMeK;T1Yt)oHcuaovRPcf3vx|G~47D%i!l_cq%6F7N1K8
zIlrVFI5T?&XCYQdf%2GGFY4t<FPh<_zNYt2x=I_(((skSGcg1LpLB!-WAf*RYcvvz
zyn_8>w^2Xub%ocgSk_XSle`0`!HGKgpl8F@q73il{hM0#SAU54Uy+XcqRyOa>t<`l
zX5dtN;q6+3wW?^%3Brf{?JHwKJ3Zu+?~4V=EGg*a7lBblp19A<hm$(mgpkf58Es^w
zdWNuhk1@X6g&Nv0eDR{(3lw)dE<`6mzlLO!8%D?eI;Z-ej{>NdivQ~N0O_?mbaB9c
zow#SP-b{%HsFQ~t+$nHGdg4z$32dXg(7(F+puFqy&wuHn#Nz~byIIU{eVr{0o(UpI
zXqJWM4ru)I|E9$5!i5CwNrN(7mzw|O{U7l7439}BB3*&p2ZDWbBqu$9hhpE{{rh(?
z1eN<aPfXksiLpO{6{MV@@Yre3qM9Ig-<2yN<8v6E+Vrvf#J_Tu@v|Piy=N*kG=?QD
z|N8Cca9cn32M`SZ+o7B8I1G>RsSCaPL6I;QS+u#5EVL&YIVigL*KhM7oxFKn&5r*^
z-wZbB#f>AKR@}?Ne&Y$jNGlFbtI2;`aS$h5f)Nw5QcwePD8wWCcO?8@oxI=B3nxP2
z6%Q}O|ME5dUpG&B4=)}n9>0|ru-|$Bd36dHaOHC1-||3XM&U3d%E@7LA2hG^+RbhD
z!tFB*@^3vcK41LP{)FIo1T4_X+n(250{L|ERjBbZ@DV%;p*u*bpKe^>pE(fiO30!!
z*U3)p^e^5=Cw~xzjf>+STf~BPKM?e=g(f2Z0iqF)U%^jIrm6@lr2n}4wf9~LM?bfN
qci_OzPD7|7H*}9bjHGx652zfa37^_9X@-9}ASos*ns)nv=l=uA!C?>p

literal 0
HcmV?d00001

diff --git a/all_static/images/whats-new-in-v4/quiver_wind.png b/all_static/images/whats-new-in-v4/quiver_wind.png
new file mode 100644
index 0000000000000000000000000000000000000000..83fef97c0b958bbc1f16d01ffc3d240b35c44198
GIT binary patch
literal 49448
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
MPDM8Vj`7R?1F(B*$^ZZW

literal 0
HcmV?d00001

diff --git a/all_static/images/whats-new-in-v4/migration_sankey_sort_auto.png b/all_static/images/whats-new-in-v4/sankey_sort_auto.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_sankey_sort_auto.png
rename to all_static/images/whats-new-in-v4/sankey_sort_auto.png
diff --git a/all_static/images/whats-new-in-v4/migration_sankey_sort_input.png b/all_static/images/whats-new-in-v4/sankey_sort_input.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_sankey_sort_input.png
rename to all_static/images/whats-new-in-v4/sankey_sort_input.png
diff --git a/all_static/images/whats-new-in-v4/migration_sankey_v3.png b/all_static/images/whats-new-in-v4/sankey_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_sankey_v3.png
rename to all_static/images/whats-new-in-v4/sankey_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_sankey_v4.png b/all_static/images/whats-new-in-v4/sankey_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_sankey_v4.png
rename to all_static/images/whats-new-in-v4/sankey_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v3.png b/all_static/images/whats-new-in-v4/scattermap_iconcolor_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v3.png
rename to all_static/images/whats-new-in-v4/scattermap_iconcolor_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v4.png b/all_static/images/whats-new-in-v4/scattermap_iconcolor_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v4.png
rename to all_static/images/whats-new-in-v4/scattermap_iconcolor_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v3.png b/all_static/images/whats-new-in-v4/scattermap_legendsymbol_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v3.png
rename to all_static/images/whats-new-in-v4/scattermap_legendsymbol_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v4.png b/all_static/images/whats-new-in-v4/scattermap_legendsymbol_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v4.png
rename to all_static/images/whats-new-in-v4/scattermap_legendsymbol_v4.png
diff --git a/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v3.png b/all_static/images/whats-new-in-v4/shape_legend_swatch_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v3.png
rename to all_static/images/whats-new-in-v4/shape_legend_swatch_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v4.png b/all_static/images/whats-new-in-v4/shape_legend_swatch_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v4.png
rename to all_static/images/whats-new-in-v4/shape_legend_swatch_v4.png
diff --git a/all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png b/all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png
new file mode 100644
index 0000000000000000000000000000000000000000..4dae7fc02bcd543e80a2f09fd1a05b22b621727c
GIT binary patch
literal 21323
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

literal 0
HcmV?d00001

diff --git a/all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png b/all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png
new file mode 100644
index 0000000000000000000000000000000000000000..192482fe452512c3f42c50db327f416a95e28d70
GIT binary patch
literal 22903
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

literal 0
HcmV?d00001

diff --git a/all_static/images/whats-new-in-v4/migration_tickmode_v3.png b/all_static/images/whats-new-in-v4/tickmode_v3.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_tickmode_v3.png
rename to all_static/images/whats-new-in-v4/tickmode_v3.png
diff --git a/all_static/images/whats-new-in-v4/migration_tickmode_v4.png b/all_static/images/whats-new-in-v4/tickmode_v4.png
similarity index 100%
rename from all_static/images/whats-new-in-v4/migration_tickmode_v4.png
rename to all_static/images/whats-new-in-v4/tickmode_v4.png

From 2dfcd3b752f5e50a716d69e07c901c4f159d22d1 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Fri, 24 Jul 2026 13:58:20 -0600
Subject: [PATCH 11/25] Add additional features to what's new, more breaking
 changes to migration guide

---
 .../2026-07-17-migrating-to-v4.md             |   63 +-
 .../2026-07-20-whats-new-in-v4.md             | 1217 ++++++++++-------
 2 files changed, 805 insertions(+), 475 deletions(-)

diff --git a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
index 39c83ce0f..96e9b2dda 100644
--- a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
+++ b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
@@ -33,7 +33,9 @@ existing code or input needs to be updated.
 - [Scattermap rendering changes](#scattermap-rendering-changes)
 - [Shape legend `line.dash`](#shape-legend-line-dash)
 - [Overlaying axis `tickmode`](#overlaying-axis-tickmode)
+- [`splom.axis.matches` default](#splomaxismatches-default)
 - [Sankey layout](#sankey-layout)
+- [MathJax v2 dropped](#mathjax-v2-dropped)
 
 ---
 
@@ -74,9 +76,11 @@ Config options removed from `Plotly.newPlot(gd, data, layout, config)`:
 | `showLink`, `linkText`, `sendData`, `showSources` | None — remove them |
 | `showEditInChartStudio` | `showSendToCloud` |
 
-The `editInChartStudio` modebar button is gone — switch to `sendDataToCloud`.
-The undocumented `stream: { token, maxpoints }` trace attribute is removed and
-now schema-rejected.
+The `editInChartStudio` modebar button is gone — switch to `sendChartToCloud`.
+The v3 alias `sendDataToCloud` for that button was also removed, so update
+any `modeBarButtonsToAdd: ['sendDataToCloud']` calls to use
+`'sendChartToCloud'`. The undocumented `stream: { token, maxpoints }` trace
+attribute is removed and now schema-rejected.
 
 ```js
 // Before
@@ -92,6 +96,30 @@ Plotly.newPlot(gd, data, layout, {
 });
 ```
 
+Also removed: every schema attribute ending in `src` (`xsrc`, `ysrc`,
+`textsrc`, `marker.colorsrc`, …) plus `layout.hidesources`. These were
+Chart Studio data-reference hooks; delete them from any figures where they
+still appear.
+
+The `Plots.graphJson()` signature is simplified — drop the third `mode`
+argument if you were passing one:
+
+```js
+// Before
+const json = Plotly.Plots.graphJson(gd, opts, mode);
+
+// After
+const json = Plotly.Plots.graphJson(gd, opts);
+```
+
+The **"Share with Plotly Cloud" button (`sendChartToCloud`) is now on by
+default** and targets `cloud.plotly.com`. If you don't want the button
+visible, opt out:
+
+```js
+Plotly.newPlot(gd, data, layout, { showSendToCloud: false });
+```
+
 ---
 
 ## Removed mapbox traces and subplots
@@ -207,6 +235,15 @@ defaulting to `'auto'`.
 
 ---
 
+## `splom.axis.matches` default
+
+`splom` (scatter plot matrix) traces now default `axis.matches` to `true`, so
+axes on the same row/column are linked and pan/zoom together. In v3 the
+default was `false` (each cell independent). To restore v3 behavior on a
+specific splom, set `matches: false` on its axes explicitly.
+
+---
+
 ## Sankey layout
 
 `@plotly/d3-sankey` was upgraded from 0.7.2 to 0.12.3. The schema is
@@ -216,3 +253,23 @@ code change needed unless you had output locked to specific pixel positions.
 To pin node/link order (for animation or side-by-side comparisons), use the
 new `sankey.node.sort` and `sankey.link.sort` attributes with `'input'`.
 Defaults preserve v3-equivalent auto ordering.
+
+---
+
+## MathJax v2 dropped
+
+Plotly.js now supports **MathJax v3 and v4** for LaTeX rendering. **MathJax
+v2 support has been removed** — figures using a v2 bundle will no longer
+render math expressions.
+
+If your page bundles MathJax v2, upgrade to v3 or v4:
+
+```html
+<!-- v3 -->
+<script src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js"></script>
+<!-- or v4 -->
+<script src="https://cdn.jsdelivr.net/npm/mathjax@4/tex-svg.js"></script>
+```
+
+The MathJax v3 and v4 syntax is unchanged, so no code changes to the call
+sites are needed once the correct bundle is loaded.
diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
index 89cdbfcda..b976de98d 100644
--- a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -19,376 +19,303 @@ v4](/javascript/guides/migrating-to-v4/).
 
 ## Contents
 
-- [Minimum Node.js version](#minimum-nodejs-version)
-- [Color library swap (tinycolor2 → color)](#color-library-swap)
-- [Chart Studio APIs removed](#chart-studio-apis-removed)
-- [Mapbox traces and subplots removed](#mapbox-traces-and-subplots-removed)
-- [Country name lookup (country-regex → country-iso-search)](#country-name-lookup)
+**New capabilities**
+
+- [Quiver trace type](#quiver-trace-type)
+- [Share with Plotly Cloud](#share-with-plotly-cloud)
+- [MathJax v4 support](#mathjax-v4-support)
+- [Sankey node and link ordering](#sankey-node-and-link-ordering)
+- [Geo subplot zoom limits](#geo-subplot-zoom-limits)
 - [TypeScript types](#typescript-types)
-- [Scattermap icon defaults](#scattermap-icon-defaults)
+
+**New defaults**
+
 - [Map subplots auto-fit to data](#map-subplots-auto-fit-to-data)
 - [Geo subplots auto-fit by default](#geo-subplots-auto-fit-by-default)
-- [Geo `fitbounds` framing for antimeridian features](#geo-fitbounds-framing-for-antimeridian-features)
-- [Geo subplot zoom limits](#geo-subplot-zoom-limits)
-- [Shape legend marker outlines honor `line.dash`](#shape-legend-marker-outlines-honor-line-dash)
 - [Overlaying axis `tickmode` defaults to `'sync'`](#overlaying-axis-tickmode-defaults-to-sync)
-- [Sankey layout algorithm update](#sankey-layout-algorithm-update)
-- [Sankey node and link ordering](#sankey-node-and-link-ordering)
-
----
-
-## Minimum Node.js version
+- [`splom.axis.matches` default flipped to `true`](#splomaxismatches-default-flipped-to-true)
+- [Shape legend marker outlines honor `line.dash`](#shape-legend-marker-outlines-honor-line-dash)
 
-*Implemented in [#7861](https://github.com/plotly/plotly.js/pull/7861).*
+**Behavior and library changes**
 
-Plotly.js now requires Node.js v22 or newer. The previous floor was v18, which
-has reached end-of-life.
+- [Color library swap](#color-library-swap)
+- [Country name lookup](#country-name-lookup)
+- [Scattermap icon defaults](#scattermap-icon-defaults)
+- [Geo `fitbounds` framing for antimeridian features](#geo-fitbounds-framing-for-antimeridian-features)
+- [Sankey layout algorithm update](#sankey-layout-algorithm-update)
 
-This only affects you if:
+**Removed**
 
-| Scenario | Why |
-|---|---|
-| You build Plotly.js from source | Contributors and custom bundles |
-| You run Plotly.js in a Node.js runtime | Server-side rendering via jsdom, validation scripts, image export pipelines, etc. |
-| You install via `yarn` or `pnpm` | Both enforce `engines` strictly (`npm` prints a warning but installs) |
+- [Chart Studio APIs removed](#chart-studio-apis-removed)
+- [Mapbox traces and subplots removed](#mapbox-traces-and-subplots-removed)
 
-Consumers who only load the pre-built browser bundle (`plotly.min.js` or a
-partial bundle like `plotly-basic.min.js`) are unaffected — the bundle runs in
-browsers, not Node.
+**Requirements**
 
-If you're on Node 18 or 20, upgrade to 22 LTS. `npm` will print a warning on
-install but won't fail; `yarn` and `pnpm` will refuse to install unless your
-environment satisfies `engines.node >= 22.0.0`.
+- [Minimum Node.js version](#minimum-nodejs-version)
 
 ---
 
-## Color library swap
-
-*Implemented in [#7536](https://github.com/plotly/plotly.js/pull/7536).*
-
-In v4, Plotly's internal color processing was switched from
-[tinycolor2](https://github.com/bgrins/TinyColor) to
-[color](https://github.com/Qix-/color). The new library is actively maintained
-and supports modern CSS Color 4 syntax, but a handful of behaviors changed in
-the process.
+## Quiver trace type
 
-### Color string inputs that no longer work
+*Implemented in [#7710](https://github.com/plotly/plotly.js/pull/7710).*
 
-**`hsv()` color strings are no longer accepted.**
+Plotly.js now ships a `quiver` trace type for visualizing 2D vector fields as
+arrays of arrows. Arrows are placed at `(x, y)` coordinates and drawn with
+direction and magnitude from `(u, v)` components.
 
 ```js
-// Before
-{ marker: { color: 'hsv(200, 80%, 80%)' } }
-
-// After — convert to hsl, hwb, hex, or rgb
-{ marker: { color: 'hsl(200, 67%, 47%)' } }
+Plotly.newPlot(gd, [{
+    type: 'quiver',
+    x: [0, 1, 2, 0, 1, 2],
+    y: [0, 0, 0, 1, 1, 1],
+    u: [1, 0.5, 0, 0.5, 0, -0.5],
+    v: [0, 0.5, 1, 0.5, 1, 0.5]
+}]);
 ```
 
-A color in the unsupported format will fall back to the attribute's default.
+![Simple 6-arrow quiver with per-arrow coloring](/all_static/images/whats-new-in-v4/quiver_simple.png)
 
-**`rgb()` / `rgba()` strings with 0–1 decimal fractions are no longer
-accepted.**
+### Positioning and sizing
 
-```js
-// Before — tinycolor parsed this as 0–1 fractions
-'rgb(0.5, 0.5, 0.5)'  // → rgb(128, 128, 128)
+| Attribute | Values | Purpose |
+|---|---|---|
+| `x`, `y` | numeric arrays | Arrow anchor positions. `x0` + `dx` / `y0` + `dy` shorthand also supported for regular grids. |
+| `u`, `v` | numeric arrays | Vector components at each `(x, y)`. |
+| `anchor` | `'tail'` (default) / `'tip'` / `'center'` | Which point of the arrow sits at `(x, y)`. |
+| `sizemode` | `'scaled'` (default) / `'raw'` | Normalize arrow lengths against the maximum vector length + point density, or draw them at their raw magnitude. |
+| `sizeref` | number (default `1`) | Multiplier applied on top of `sizemode`. |
+| `anglemode` | `'data'` / `'paper'` | In `'data'`, angles are measured in data coordinates and change with axis zoom or non-uniform scaling; in `'paper'`, angles stay fixed in pixel space. |
 
-// After — the underlying library reads them as integer 0–255 (truncated)
-'rgb(0.5, 0.5, 0.5)'  // → rgb(1, 1, 1)
-```
+### Styling
 
-Convert any inputs of the form `rgb(0.5, 0.5, 0.5)` to `rgb(128, 128, 128)`
-(or any other supported color string) before passing them to Plotly.
+Arrow lines are styled through `marker.line.width` and `marker.line.dash`.
+`marker.arrowsize` scales the arrowhead relative to the line width — a value
+of `1` (default) gives a head about 3× the line width.
 
-Mixed-format strings where at least one component is `>= 1` (e.g. `rgb(255,
-0.0, 0.0)`) continue to render correctly: the new parser treats the `0.0`
-components as integer `0`.
+### Coloring arrows by a scalar field
 
-**Numeric color inputs are now rejected.**
+Pass a `c` array (one value per arrow) plus the usual colorscale attributes
+(`marker.colorscale`, `marker.cmin`, `marker.cmax`, `marker.showscale`,
+`marker.colorbar`) to color each arrow by an independent scalar. Without `c`,
+every arrow uses `marker.color`.
 
 ```js
-// Before — silently accepted, rendered as near-black
-{ marker: { color: 42 } }
-
-// After — falls back to the attribute default
+{
+    type: 'quiver',
+    x: [/* … */], y: [/* … */],
+    u: [/* … */], v: [/* … */],
+    marker: {
+        color: [/* one value per arrow */],
+        colorscale: 'Viridis',
+        showscale: true
+    }
+}
 ```
 
-If you were relying on numeric color values being coerced, convert them to
-color strings before passing them to Plotly.
-
-### Color computation output changes
-
-A handful of Plotly's derived colors shift by a few RGB units. Visible places
-where output shifts:
-
-| Where | Example |
-|---|---|
-| Heatmap auto-contrast text | Cells in the mid-luminance range flip between dark grey and white on colorscales like Viridis or Jet |
-| Auto-generated `insidetextfont` color on bars/waterfall | Same threshold shift around mid-luminance backgrounds |
-| Sankey default hover color (dark BG) | RGB channels shift by 1 unit per channel vs v3 |
+### Selection
 
-Example — the four cells with `z` values 55, 56, and 60 (both occurrences)
-shift their text from white in v3 to dark grey in v4 on a Viridis heatmap,
-because the underlying color library computes cell luminance with a slightly
-different formula.
+Quiver supports box and lasso selection through the standard `selected` /
+`unselected` marker attributes and appears in the modebar selection buttons
+like other cartesian traces.
 
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 Viridis heatmap with white text on mid-luminance cells](/all_static/images/whats-new-in-v4/migration_color_heatmap_v3.png) | ![v4 Viridis heatmap with dark text on those cells](/all_static/images/whats-new-in-v4/migration_color_heatmap_v4.png) |
+### Example: wind field
 
-### New color formats you can now use
+A larger example showing arrows colored by magnitude:
 
-The new library accepts CSS Color 4 syntax that wasn't possible with
-tinycolor. All of these are now valid anywhere Plotly accepts a color string:
+![Vector wind field visualization with arrows colored by speed](/all_static/images/whats-new-in-v4/quiver_wind.png)
 
-```js
-'#ff0000aa'          // 8-digit hex with alpha
-'#f00a'              // 4-digit short hex with alpha
-'rgb(255 0 0)'       // space-separated rgb
-'rgba(255 0 0 / 0.5)' // slash-alpha rgba
-'hsl(0 100% 50% / 0.5)' // slash-alpha hsl
-'hsla(0, 100%, 50%, 0.5)' // hsla
-'hwb(0, 0%, 0%)'     // hwb (hue-whiteness-blackness)
-```
+---
 
-See
-[test/image/mocks/color_syntax_formats.json](https://github.com/plotly/plotly.js/blob/master/test/image/mocks/color_syntax_formats.json)
-for a working example using each format.
+## Share with Plotly Cloud
 
-#### Browser compatibility
+*Implemented in [#7802](https://github.com/plotly/plotly.js/pull/7802),
+[#7852](https://github.com/plotly/plotly.js/pull/7852),
+[#7854](https://github.com/plotly/plotly.js/pull/7854), and
+[#7909](https://github.com/plotly/plotly.js/pull/7909).*
 
-All of these are parsed by Plotly in JavaScript and normalized to legacy
-`rgb(...)` / `rgba(...)` before being written to the DOM, so the browser never
-sees the modern syntax — your figures render the same in any browser that ran
-v3. The note below only matters if you also mirror these strings into your own
-stylesheets or template literals.
+Plotly.js can now share the current figure to
+[Plotly Cloud](https://cloud.plotly.com) from a one-click modebar button.
+The button posts the figure's data and layout to `cloud.plotly.com` and
+returns a shareable URL — the successor to the old Chart Studio upload
+flow, but without the Chart Studio-specific config surface (`showLink`,
+`sendData`, `showSources`, etc. — those are all gone; see
+[Chart Studio APIs removed](#chart-studio-apis-removed)).
 
-Native CSS support:
+The button is enabled by default in v4:
 
-| Format | First supported |
-|---|---|
-| `#rrggbbaa`, `#rgba` | Chrome 62 (2017), Firefox 49 (2016), Safari 9.1 (2016) |
-| `rgb(r g b)`, `rgb(r g b / a)`, `hsl(h s l / a)` (space + slash-alpha) | Chrome 65 (2018), Firefox 52 (2017), Safari 12.1 (Mar 2019) |
-| `hsla()` | Universal since IE9 |
-| `hwb()` | Chrome 101 (Apr 2022), Firefox 96 (Jan 2022), Safari 15 (Sep 2021) |
+![Share with Plotly Cloud button](/all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png)
 
-`hwb()` is the only format here that won't parse in browsers from ~2020 or
-earlier. Everything else is safe in any browser shipped in the last seven
-years.
+Clicking the button brings up the share dialog:
 
----
+![Share with Plotly Cloud dialog](/all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png)
 
-## Chart Studio APIs removed
+### Config
 
-*Implemented in [#7812](https://github.com/plotly/plotly.js/pull/7812).*
+The button is controlled by two config options:
 
-The legacy "Edit in Chart Studio" link, related config options, and the
-streaming token attribute have been removed. The `sendDataToCloud` modebar
-button and config option are retained — only the duplicate `editInChartStudio`
-button and the on-graph "Edit chart" link are gone.
+| Config option | Default | Purpose |
+|---|---|---|
+| `showSendToCloud` | `true` | Whether the "Share with Plotly Cloud" modebar button is rendered. |
+| `plotlyServerURL` | `'cloud.plotly.com'` | The endpoint the button posts to. Override to point at a self-hosted or alternate server. |
 
-### Removed config options
+The button's internal name (in `modeBarButtonsToAdd`, event handlers, etc.)
+is `sendChartToCloud`. In v3 both `sendChartToCloud` and the alias
+`sendDataToCloud` worked; in v4 the alias is removed — code that referred to
+the button by the `sendDataToCloud` name needs to be updated.
 
-`Plotly.newPlot(gd, data, layout, config)` no longer accepts:
+### Opting out
 
-| Removed | What it did | Replacement |
-|---|---|---|
-| `showLink` | Drew an "Edit chart" link at the bottom-right of the plot | None — remove the option |
-| `linkText` | Text for the `showLink` link | None — remove the option |
-| `sendData` | Whether the link uploaded data or just linked to a file | None — remove the option |
-| `showSources` | Hook that drew custom source links next to `showLink` | None — remove the option |
-| `showEditInChartStudio` | Pencil-icon variant of `sendDataToCloud` | Use `showSendToCloud` |
+Hide the button by setting `showSendToCloud: false`:
 
 ```js
-// Before
-Plotly.newPlot(gd, data, layout, {
-    showLink: true,
-    linkText: 'View on Plotly',
-    showEditInChartStudio: true,
-});
-
-// After
 Plotly.newPlot(gd, data, layout, {
-    showSendToCloud: true,
+    showSendToCloud: false
 });
 ```
 
-### Removed modebar button
-
-`editInChartStudio` is no longer a built-in modebar button. If you were adding
-it explicitly via `modeBarButtonsToAdd`, switch to `sendDataToCloud`:
+Or point the upload at a different host:
 
 ```js
-// Before
-{ modeBarButtonsToAdd: ['editInChartStudio'] }
-
-// After
-{ modeBarButtonsToAdd: ['sendDataToCloud'] }
+Plotly.newPlot(gd, data, layout, {
+    plotlyServerURL: 'https://my-plotly-mirror.example.com'
+});
 ```
 
-### Removed trace attribute
+### Endpoint status
 
-The undocumented `stream` attribute (`stream.token`, `stream.maxpoints`) has
-been removed from every trace type. It was a hook for the Chart Studio
-streaming service, which is no longer reachable. If you have figures
-containing `stream: { token: '...', maxpoints: N }` in their trace objects,
-delete those properties — they're now schema-rejected.
+The `cloud.plotly.com` endpoint is **not yet functional at the v4 release**.
+The button renders and is wired up, but clicking it does not complete an
+upload until the endpoint is deployed. Once it goes live, existing figures
+running v4 with the default config will start supporting uploads without
+any code change on the caller side.
 
----
+### History
 
-## Mapbox traces and subplots removed
+The upload flow was built out across the Plotly.js 3.7 series
+(#7802 / #7852 / #7854), but shipped with `showSendToCloud` defaulting to
+`false`, so unless you set the flag manually you never saw the button.
+v4 (#7909) flips the default so every new figure exposes it by default —
+this is a functional feature reveal, not a new API.
 
-*Implemented in [#7860](https://github.com/plotly/plotly.js/pull/7860).*
+---
 
-The legacy mapbox-gl-js–based traces and subplot type have been removed. The
-MapLibre-based `map` family that has shadowed them since v2 is now the only
-map implementation. For deeper background on the switch, see [Mapbox to
-MapLibre migration](https://plotly.com/python/mapbox-to-maplibre/).
+## MathJax v4 support
 
-### Removed
+*Implemented in [#7898](https://github.com/plotly/plotly.js/pull/7898).*
 
-| Removed | Replacement |
-|---|---|
-| `scattermapbox` trace | `scattermap` |
-| `choroplethmapbox` trace | `choroplethmap` |
-| `densitymapbox` trace | `densitymap` |
-| `layout.mapbox` subplot (and `mapbox2`, `mapbox3`, …) | `layout.map` (and `map2`, `map3`, …) |
-| `layout.mapbox.accesstoken` | None — MapLibre uses open tile providers |
-| `mapboxAccessToken` config option | None — see above |
-| `plotly-mapbox.min.js` partial bundle | `plotly-map.min.js` |
-| Modebar buttons `zoomInMapbox`, `zoomOutMapbox`, `resetViewMapbox` | `zoomInMap`, `zoomOutMap`, `resetViewMap` |
-| `scrollZoom` flag value `'mapbox'` (e.g. `scrollZoom: 'mapbox+cartesian'`) | `'map'` |
+Plotly.js now supports **MathJax v3 and v4** for rendering LaTeX in labels,
+titles, annotations, and hover text. Support for **MathJax v2 has been
+dropped** — figures that rely on a v2 bundle will no longer render their math
+expressions.
 
-The schema for `map` mirrors `mapbox` attribute-for-attribute (`domain`,
-`style`, `center`, `zoom`, `bearing`, `pitch`, `bounds`, `layers[...]`), so
-the migration is usually a rename.
+MathJax v3 and v4 share the same rendering syntax, so Plotly no longer needs
+version-specific code paths internally. Beyond dropping v2, the internal
+`svg_text_utils.js` rewrite makes math rendering somewhat faster.
 
-```js
-// Before
-{
-    data: [{ type: 'scattermapbox', lon: [...], lat: [...] }],
-    layout: {
-        mapbox: {
-            style: 'open-street-map',
-            center: { lon: 0, lat: 0 },
-            zoom: 2,
-        },
-    },
-    config: { mapboxAccessToken: 'pk.eyJ1...' },
-}
+### What to do
 
-// After
-{
-    data: [{ type: 'scattermap', lon: [...], lat: [...] }],
-    layout: {
-        map: {
-            style: 'open-street-map',
-            center: { lon: 0, lat: 0 },
-            zoom: 2,
-        },
-    },
-    // mapboxAccessToken removed — MapLibre needs no token for the
-    // built-in styles
-}
-```
+- Loading MathJax v2 in the page? Upgrade to v3 or v4. The tex-svg build is
+  the one Plotly integrates with:
+  ```html
+  <!-- v3 (still supported) -->
+  <script src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js"></script>
+  <!-- or v4 (new) -->
+  <script src="https://cdn.jsdelivr.net/npm/mathjax@4/tex-svg.js"></script>
+  ```
+- Already on v3? No action required — your math expressions continue to
+  render.
+- On v4 already? No action required either.
 
-### Built-in style values
+### Call sites unchanged
 
-Every built-in `style` name that worked on `mapbox` still works on `map`, but
-the tiles backing them differ — visual output **will change** even when no
-other figure changes:
+Plotly's public API for math (using `$…$` in text attributes) is unchanged.
+The version negotiation happens inside Plotly at runtime — the correct
+rendering path is chosen based on what MathJax exposes.
 
-| Style name | Old (`mapbox`) | New (`map`) |
-|---|---|---|
-| `basic`, `streets`, `outdoors` | mapbox.com vector tiles (required token) | Carto Voyager |
-| `light` | mapbox.com light | Carto Positron |
-| `dark` | mapbox.com dark | Carto Dark Matter |
-| `satellite`, `satellite-streets` | mapbox.com satellite | ArcGIS World Imagery |
-| `white-bg`, `open-street-map` | unchanged | unchanged |
-| `carto-*`, `carto-*-nolabels` | n/a (already open) | unchanged |
+---
 
-The three Stamen styles (`stamen-terrain`, `stamen-toner`,
-`stamen-watercolor`) are gone — Stamen tiles now require a Stadia API key.
-Users who need them can supply a custom `style` URL.
+## Sankey node and link ordering
 
-### Custom style URLs
+*Implemented in [#7873](https://github.com/plotly/plotly.js/pull/7873).*
 
-Custom MapLibre / Mapbox-style JSON URLs continue to work. The
-`mapbox://styles/mapbox/...` short form is no longer resolved, since it
-requires authenticating to mapbox.com. Substitute the full URL of an
-equivalent open style, or self-host the style JSON.
+Two new attributes let you override the automatic ordering that v4's d3-sankey
+algorithm applies:
 
----
+| Attribute | Default | `'input'` value |
+|---|---|---|
+| `sankey.node.sort` | `'auto'` | Preserves the vertical order of nodes as given in `node.label`, disabling the layout's default y-axis reordering. |
+| `sankey.link.sort` | `'auto'` | Preserves the order in which links are given in `link.source` / `link.target`, disabling the layout's per-node link ordering. |
 
-## Country name lookup
+Defaults reproduce v3 behavior, so no code change is needed on upgrade. Use
+`'input'` when you want a stable, deterministic ordering across renders —
+animation, side-by-side comparisons, or figures where the input order carries
+semantic meaning that the layout would otherwise obscure.
 
-*Implemented in [#7856](https://github.com/plotly/plotly.js/pull/7856).*
-
-`locationmode: 'country names'` on `choropleth` and `scattergeo` traces is now
-resolved by [country-iso-search](https://github.com/plotly/country-iso-search)
-instead of [country-regex](https://github.com/etpinard/country-regex). The
-attribute name, accepted values list, and ISO-3 output are unchanged — the
-difference is in *how* a name string is matched to an alpha-3 code.
+```js
+Plotly.newPlot(gd, [{
+    type: 'sankey',
+    node: {
+        label: [/* … */],
+        sort: 'input'
+    },
+    link: {
+        source: [/* … */],
+        target: [/* … */],
+        value:  [/* … */],
+        sort: 'input'
+    }
+}]);
+```
 
-The old library walked a table of country-specific regular expressions and
-returned the first match. That made it lenient (substring matches worked) but
-ambiguity-prone — strings like `'Republic of'` could resolve to whichever
-entry's regex hit first. The new library does a sanitized exact lookup against
-a curated alias table, which is stricter about ambiguous input but accepts
-many more legitimate forms.
+The `sort` attribute is not honored on circular Sankey diagrams — those
+continue to use `d3-sankey-circular`, which has no equivalent hook.
 
-### Previously recognized names that no longer work
+Same data, same code — only the `sort` value differs:
 
-Strings that only matched because of overly broad regex fragments now fall
-back to the unrecognized-name log message and the location is skipped. In
-practice this hits inputs that weren't really country names — partial phrases,
-generic descriptors, or strings containing a country name as a substring of
-something else (e.g. `'Republic of Foo'`, `'Not Iran'`). If you were relying
-on a non-canonical form, switch to the country's name, an alias, or the ISO-3
-/ ISO-2 code.
+| `sort: 'auto'` (default) | `sort: 'input'` |
+|---|---|
+| ![auto reorders sources to reduce crossings](/all_static/images/whats-new-in-v4/sankey_sort_auto.png) | ![input preserves the given order, crossings and all](/all_static/images/whats-new-in-v4/sankey_sort_input.png) |
 
-### Names and forms that now resolve
+In this figure the source nodes are given as `[A, B, C, D]` and paired
+one-to-one with targets `[Z, Y, X, W]` — a maximally-crossed input. `'auto'`
+flips the source column to `D, C, B, A` so the primary flows run horizontally;
+`'input'` leaves both columns in the given order and preserves every crossing.
 
-The alias table is larger and the input is normalized before lookup, so a
-number of forms that previously failed now work:
+---
 
-```js
-// All resolve to 'FRA'
-'France'
-'FR'                        // ISO 3166-1 alpha-2
-250                         // UN M49 numeric (number or string)
-'\u{1F1EB}\u{1F1F7}'        // flag emoji
+## Geo subplot zoom limits
 
-// Historical / native / punctuated names
-'Burma'                     // → 'MMR'
-'Türkiye'                   // → 'TUR' (diacritics stripped)
-'Cote d\'Ivoire'            // → 'CIV' (apostrophes ignored)
-'St. Kitts and Nevis'       // → 'KNA' ('St.' expands to 'Saint')
-'The Gambia'                // → 'GMB' (leading 'The ' dropped)
-```
+*Implemented in [#7371](https://github.com/plotly/plotly.js/pull/7371).*
 
-Matching is case-insensitive. Sanitization also collapses internal whitespace,
-drops `.` `()` `,`, maps `&` → `and`, and turns `-` / `–` / `—` into spaces —
-so cosmetic punctuation differences in your input data no longer block a
-match.
+Geo subplots accept two new attributes for clamping interactive zoom:
 
-### Disputed-territory codes are retained
+| Attribute | Default | Effect |
+|---|---|---|
+| `layout.geo.projection.minscale` | `0` | Lower bound on zoom, expressed as a multiplier of `projection.scale`. `0` means no lower bound. |
+| `layout.geo.projection.maxscale` | `null` | Upper bound on zoom, expressed as a multiplier of `projection.scale`. `null` means no upper bound. |
 
-The user-assigned alpha-3 codes Plotly historically recognized for disputed
-regions still work:
+```js
+Plotly.newPlot(gd, [/* … */], {
+    geo: {
+        projection: {
+            scale: 1,
+            minscale: 0.5,   // can't zoom out past 50% of base
+            maxscale: 4,     // can't zoom in past 400% of base
+        },
+    },
+});
+```
 
-| Code | Region |
-|---|---|
-| `XAC` | Aksai Chin |
-| `XAP` | Arunachal Pradesh |
-| `XBT` | Bir Tawil |
-| `XHT` | Halaib Triangle |
-| `XJK` | Jammu and Kashmir |
+The defaults preserve v3 behavior — figures that don't set these attributes
+are unaffected.
 
-These are layered on top of the standard ISO 3166-1 records via
-[src/lib/custom_country_codes.ts](https://github.com/plotly/plotly.js/blob/master/src/lib/custom_country_codes.ts).
-Whether a feature for them appears on the rendered map still depends on the
-topojson resolution in use.
+One init-time wrinkle: if `projection.scale` falls outside `[minscale,
+maxscale]`, Plotly now dispatches a synthetic zoom event on first plot to
+clamp it back into range. That emits a `plotly_relayout` event that v3
+wouldn't have fired. If you have a listener that distinguishes user-driven
+zooms from programmatic ones, make sure it tolerates a single extra event at
+startup for figures whose initial `projection.scale` is outside the configured
+bounds.
 
 ---
 
@@ -473,58 +400,6 @@ compiling. New code should prefer `TraceType`.
 
 ---
 
-## Scattermap icon defaults
-
-*Implemented in [#7825](https://github.com/plotly/plotly.js/pull/7825).*
-
-If you used `scattermap` or `scattermapbox` in v3, three rendering details
-have changed by the time you land on `scattermap` in v4:
-
-### Marker icons now respect `marker.color`
-
-`marker.color` on a scattermap trace is now applied to the icon by setting
-`icon-color`.
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 scattermap icons uncolored](/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v3.png) | ![v4 scattermap icons tinted red](/all_static/images/whats-new-in-v4/migration_scattermap_iconcolor_v4.png) |
-
-### Maki icon set updated to v8 (via jsDelivr)
-
-The icon CDN and version have changed:
-
-| Version | URL |
-|---|---|
-| v3 | `https://unpkg.com/maki@2.1.0/icons/<name>.svg` |
-| v4 | `https://cdn.jsdelivr.net/npm/@mapbox/maki@8.2.0/icons/<name>.svg` |
-
-A handful of icon names removed between Maki 2.1 and 8.2 will now silently
-fail to load (HTTP 404). If you were using one of the dropped icons, swap it
-for the nearest Maki 8 equivalent (see [Maki 8 icon
-list](https://labs.mapbox.com/maki-icons/)).
-
-### Legend swatch always renders as a circle
-
-`scattermap` legend swatches now always draw a circle, regardless of
-`marker.symbol`. In v3 the swatch went through the same code path as cartesian
-traces, which only understands the [Plotly-supported symbol
-names](https://github.com/plotly/plotly.js/blob/master/src/components/drawing/symbol_defs.js).
-On map traces, that produced inconsistent output: symbols with names that
-don't overlap the Plotly set (Maki-only names like `'airport'`, `'cafe'`)
-rendered as filled circles, while other symbols (`'square'`, `'star'`, etc.)
-rendered as broken/empty paths in the legend even though they draw correctly
-on the map. The v4 circle fallback makes the swatch consistent across every
-scattermap trace.
-
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 scattermap legend inconsistent](/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v3.png) | ![v4 scattermap legend all circles](/all_static/images/whats-new-in-v4/migration_scattermap_legendsymbol_v4.png) |
-
-If you were styling the legend swatch path directly based on `marker.symbol`,
-that selector will now always match a circle path on map traces.
-
----
-
 ## Map subplots auto-fit to data
 
 *Implemented in [#7884](https://github.com/plotly/plotly.js/pull/7884).*
@@ -547,7 +422,7 @@ Plotly.newPlot(gd, [{
 
 | Before (v3) | After (v4) |
 |---|---|
-| ![v3 map with world view](/all_static/images/whats-new-in-v4/migration_map_autofit_v3.png) | ![v4 map framed on cities](/all_static/images/whats-new-in-v4/migration_map_autofit_v4.png) |
+| ![v3 map with world view](/all_static/images/whats-new-in-v4/map_autofit_v3.png) | ![v4 map framed on cities](/all_static/images/whats-new-in-v4/map_autofit_v4.png) |
 
 Auto-fitting runs on the initial render and again on data-only updates
 (`Plotly.restyle` of `lon`/`lat`, `Plotly.addTraces`, `Plotly.deleteTraces`)
@@ -641,7 +516,7 @@ Plotly.newPlot(gd, [{
 
 | Before (v3) | After (v4) |
 |---|---|
-| ![v3 geo world view](/all_static/images/whats-new-in-v4/migration_geo_autofit_v3.png) | ![v4 geo framed on Canada+Mexico](/all_static/images/whats-new-in-v4/migration_geo_autofit_v4.png) |
+| ![v3 geo world view](/all_static/images/whats-new-in-v4/geo_autofit_v3.png) | ![v4 geo framed on Canada+Mexico](/all_static/images/whats-new-in-v4/geo_autofit_v4.png) |
 
 ### Disabling auto-fitting
 
@@ -715,99 +590,96 @@ reset is the fitted view.
 
 ---
 
-## Geo `fitbounds` framing for antimeridian features
-
-*Implemented in [#7891](https://github.com/plotly/plotly.js/pull/7891).*
+## Overlaying axis `tickmode` defaults to `'sync'`
 
-`layout.geo.fitbounds: 'locations'` (and `'geojson'`) now correctly frames
-choropleth and scattergeo location traces containing features that cross the
-±180° antimeridian — Russia, Fiji, Antarctica, New Zealand, and the Aleutian
-Islands portion of Alaska. In v3 these were mis-framed because the underlying
-bounding-box computation (`@turf/bbox`) reported a bogus whole-globe span
-(`[-180°, 180°]`) for any such feature, and the fit zoomed the map out to
-match. In v4, `computeBbox` uses `d3-geo.geoBounds`' widest-gap longitude
-algorithm on the feature's vertices and returns the compact crossing range
-(with `east > 180°` when the range wraps).
+*Implemented in [#7684](https://github.com/plotly/plotly.js/pull/7684).*
 
-Because v4 also flips the `fitbounds` default from `false` to `'locations'`
-(see [Geo subplots auto-fit by default](#geo-subplots-auto-fit-by-default)),
-figures that never set `fitbounds` explicitly now participate in auto-fit too
-— so this antimeridian fix reaches many more figures than it would have as a
-standalone change.
+An axis that overlays another axis (`layout.xaxis2.overlaying: 'x'`,
+`layout.yaxis2.overlaying: 'y'`, etc.) now defaults its `tickmode` to `'sync'`
+instead of `'auto'`. The overlay axis draws tick marks and gridlines at the
+same positions as its base axis, computing labels to match — rather than
+picking its own auto-fit tick positions.
 
-### Which figures shift
+In v3 the two axes drew independent auto-tick grids, producing staggered
+gridlines that were hard to read and left no visual association between a
+gridline and a specific axis. Sync eliminates that overlap.
 
-A figure sees a visible change when **both** of the following hold:
+```js
+Plotly.newPlot(gd, [
+    { y: [1, 3, 2], name: 'A' },
+    { y: [100, 300, 200], name: 'B', yaxis: 'y2' }
+], {
+    yaxis2: { overlaying: 'y', side: 'right' }
+    // v3: y2 picks its own ticks, producing a staggered grid
+    // v4: y2 places ticks at y's tick positions, with y2-range labels
+});
+```
 
-| Condition | Detail |
+| Before (v3) | After (v4) |
 |---|---|
-| `layout.geo.fitbounds` is active | Either explicitly set to `'locations'` / `'geojson'`, or left at the v4 default (see the opt-out list in the auto-fit-default section above). |
-| The figure contains an antimeridian-crossing feature | A `choropleth` or `scattergeo` trace with `locations` where at least one location resolves to a feature that crosses ±180°. |
+| ![v3 staggered overlay ticks](/all_static/images/whats-new-in-v4/tickmode_v3.png) | ![v4 sync'd overlay ticks](/all_static/images/whats-new-in-v4/tickmode_v4.png) |
 
-Figures that opt out of auto-fit (`fitbounds: false`, an explicit view
-attribute, or one of the projections listed as skipping auto-fit), or that
-don't include an antimeridian-crossing feature, render identically to v3 as
-far as this fix is concerned.
+### Exception: categorical / multicategory base axes
 
-### Example
+When the overlaid (base) axis is `type: 'category'` or `'multicategory'`,
+`tickmode` continues to default to `'auto'` on the overlaying axis. Sync'ing
+tick positions to category slots is almost never the intent.
+
+### Opting out
+
+Set `tickmode: 'auto'` (or any other explicit value) on the overlaying axis to
+restore v3 behavior:
 
 ```js
-Plotly.newPlot(gd, [{
-    type: 'choropleth',
-    locations: ['RUS'],
-    z: [1],
-    colorscale: [[0, '#c33'], [1, '#c33']],
-    showscale: false
-}], {
-    geo: { fitbounds: 'locations', projection: { type: 'equirectangular' } },
-    width: 700,
-    height: 500
-});
-// v3: fits to a bogus [-180°, 180°] span — Russia is a small red strip at
-//     the top of the whole world.
-// v4: fits tightly to Russia's actual longitudinal extent (~19° through
-//     ~190°, unwrapped across the antimeridian).
+{ yaxis2: { overlaying: 'y', side: 'right', tickmode: 'auto' } }
 ```
 
-| Before (v3) | After (v4) |
-|---|---|
-| ![v3 Russia mis-framed with empty space](/all_static/images/whats-new-in-v4/migration_antimeridian_v3.png) | ![v4 Russia tightly framed](/all_static/images/whats-new-in-v4/migration_antimeridian_v4.png) |
+### Incidental bug fix
+
+`showexponent`, `showtickprefix`, and `showticksuffix` values of `'first'` and
+`'last'` were previously ignored on axes rendered with `tickmode: 'sync'`. Any
+workaround for that (e.g., forcing `'all'` on overlay axes) is no longer
+needed in v4.
 
 ---
 
-## Geo subplot zoom limits
+## `splom.axis.matches` default flipped to `true`
 
-*Implemented in [#7371](https://github.com/plotly/plotly.js/pull/7371).*
+*Implemented in [#7843](https://github.com/plotly/plotly.js/pull/7843).*
 
-Geo subplots accept two new attributes for clamping interactive zoom:
+`splom` (scatter plot matrix) traces now default `axis.matches` to `true`.
+That means axes on the same row are linked, and axes in the same column are
+linked, so pan and zoom propagate through the matrix as a group. In v3 the
+default was `false`, so each cell had its own independent axes.
 
-| Attribute | Default | Effect |
-|---|---|---|
-| `layout.geo.projection.minscale` | `0` | Lower bound on zoom, expressed as a multiplier of `projection.scale`. `0` means no lower bound. |
-| `layout.geo.projection.maxscale` | `null` | Upper bound on zoom, expressed as a multiplier of `projection.scale`. `null` means no upper bound. |
+Plotly Express has always set `matches: true` on generated splom plots, so
+this brings the raw Plotly.js default in line with what Express users
+already saw.
 
 ```js
-Plotly.newPlot(gd, [/* … */], {
-    geo: {
-        projection: {
-            scale: 1,
-            minscale: 0.5,   // can't zoom out past 50% of base
-            maxscale: 4,     // can't zoom in past 400% of base
-        },
-    },
-});
+Plotly.newPlot(gd, [{
+    type: 'splom',
+    dimensions: [/* … */]
+}]);
+// v3: pan/zoom on one cell only affects that cell's axes
+// v4: pan/zoom on one cell also pans/zooms every cell in the same row and column
 ```
 
-The defaults preserve v3 behavior — figures that don't set these attributes
-are unaffected.
+### Opting out
 
-One init-time wrinkle: if `projection.scale` falls outside `[minscale,
-maxscale]`, Plotly now dispatches a synthetic zoom event on first plot to
-clamp it back into range. That emits a `plotly_relayout` event that v3
-wouldn't have fired. If you have a listener that distinguishes user-driven
-zooms from programmatic ones, make sure it tolerates a single extra event at
-startup for figures whose initial `projection.scale` is outside the configured
-bounds.
+Set `axis.matches: false` explicitly to restore v3 behavior:
+
+```js
+{
+    type: 'splom',
+    dimensions: [/* … */],
+    xaxes: [{ matches: false }, /* … */],
+    yaxes: [{ matches: false }, /* … */]
+}
+```
+
+Or set `matches: false` per axis via `layout.xaxis`/`layout.yaxis` if you
+want to unlink specific axes only.
 
 ---
 
@@ -838,60 +710,307 @@ Plotly.newPlot(gd, [], {
 
 | Before (v3) | After (v4) |
 |---|---|
-| ![v3 shape legend outlines solid](/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v3.png) | ![v4 shape legend outlines dashed](/all_static/images/whats-new-in-v4/migration_shape_legend_swatch_v4.png) |
+| ![v3 shape legend outlines solid](/all_static/images/whats-new-in-v4/shape_legend_swatch_v3.png) | ![v4 shape legend outlines dashed](/all_static/images/whats-new-in-v4/shape_legend_swatch_v4.png) |
 
 ---
 
-## Overlaying axis `tickmode` defaults to `'sync'`
+## Color library swap
 
-*Implemented in [#7684](https://github.com/plotly/plotly.js/pull/7684).*
+*Implemented in [#7536](https://github.com/plotly/plotly.js/pull/7536).*
 
-An axis that overlays another axis (`layout.xaxis2.overlaying: 'x'`,
-`layout.yaxis2.overlaying: 'y'`, etc.) now defaults its `tickmode` to `'sync'`
-instead of `'auto'`. The overlay axis draws tick marks and gridlines at the
-same positions as its base axis, computing labels to match — rather than
-picking its own auto-fit tick positions.
+In v4, Plotly's internal color processing was switched from
+[tinycolor2](https://github.com/bgrins/TinyColor) to
+[color](https://github.com/Qix-/color). The new library is actively maintained
+and supports modern CSS Color 4 syntax, but a handful of behaviors changed in
+the process.
 
-In v3 the two axes drew independent auto-tick grids, producing staggered
-gridlines that were hard to read and left no visual association between a
-gridline and a specific axis. Sync eliminates that overlap.
+### Color string inputs that no longer work
+
+**`hsv()` color strings are no longer accepted.**
 
 ```js
-Plotly.newPlot(gd, [
-    { y: [1, 3, 2], name: 'A' },
-    { y: [100, 300, 200], name: 'B', yaxis: 'y2' }
-], {
-    yaxis2: { overlaying: 'y', side: 'right' }
-    // v3: y2 picks its own ticks, producing a staggered grid
-    // v4: y2 places ticks at y's tick positions, with y2-range labels
-});
+// Before
+{ marker: { color: 'hsv(200, 80%, 80%)' } }
+
+// After — convert to hsl, hwb, hex, or rgb
+{ marker: { color: 'hsl(200, 67%, 47%)' } }
+```
+
+A color in the unsupported format will fall back to the attribute's default.
+
+**`rgb()` / `rgba()` strings with 0–1 decimal fractions are no longer
+accepted.**
+
+```js
+// Before — tinycolor parsed this as 0–1 fractions
+'rgb(0.5, 0.5, 0.5)'  // → rgb(128, 128, 128)
+
+// After — the underlying library reads them as integer 0–255 (truncated)
+'rgb(0.5, 0.5, 0.5)'  // → rgb(1, 1, 1)
+```
+
+Convert any inputs of the form `rgb(0.5, 0.5, 0.5)` to `rgb(128, 128, 128)`
+(or any other supported color string) before passing them to Plotly.
+
+Mixed-format strings where at least one component is `>= 1` (e.g. `rgb(255,
+0.0, 0.0)`) continue to render correctly: the new parser treats the `0.0`
+components as integer `0`.
+
+**Numeric color inputs are now rejected.**
+
+```js
+// Before — silently accepted, rendered as near-black
+{ marker: { color: 42 } }
+
+// After — falls back to the attribute default
 ```
 
+If you were relying on numeric color values being coerced, convert them to
+color strings before passing them to Plotly.
+
+### Color computation output changes
+
+A handful of Plotly's derived colors shift by a few RGB units. Visible places
+where output shifts:
+
+| Where | Example |
+|---|---|
+| Heatmap auto-contrast text | Cells in the mid-luminance range flip between dark grey and white on colorscales like Viridis or Jet |
+| Auto-generated `insidetextfont` color on bars/waterfall | Same threshold shift around mid-luminance backgrounds |
+| Sankey default hover color (dark BG) | RGB channels shift by 1 unit per channel vs v3 |
+
+Example — the four cells with `z` values 55, 56, and 60 (both occurrences)
+shift their text from white in v3 to dark grey in v4 on a Viridis heatmap,
+because the underlying color library computes cell luminance with a slightly
+different formula.
+
 | Before (v3) | After (v4) |
 |---|---|
-| ![v3 staggered overlay ticks](/all_static/images/whats-new-in-v4/migration_tickmode_v3.png) | ![v4 sync'd overlay ticks](/all_static/images/whats-new-in-v4/migration_tickmode_v4.png) |
+| ![v3 Viridis heatmap with white text on mid-luminance cells](/all_static/images/whats-new-in-v4/color_heatmap_v3.png) | ![v4 Viridis heatmap with dark text on those cells](/all_static/images/whats-new-in-v4/color_heatmap_v4.png) |
 
-### Exception: categorical / multicategory base axes
+### New color formats you can now use
 
-When the overlaid (base) axis is `type: 'category'` or `'multicategory'`,
-`tickmode` continues to default to `'auto'` on the overlaying axis. Sync'ing
-tick positions to category slots is almost never the intent.
+The new library accepts CSS Color 4 syntax that wasn't possible with
+tinycolor. All of these are now valid anywhere Plotly accepts a color string:
 
-### Opting out
+```js
+'#ff0000aa'          // 8-digit hex with alpha
+'#f00a'              // 4-digit short hex with alpha
+'rgb(255 0 0)'       // space-separated rgb
+'rgba(255 0 0 / 0.5)' // slash-alpha rgba
+'hsl(0 100% 50% / 0.5)' // slash-alpha hsl
+'hsla(0, 100%, 50%, 0.5)' // hsla
+'hwb(0, 0%, 0%)'     // hwb (hue-whiteness-blackness)
+```
 
-Set `tickmode: 'auto'` (or any other explicit value) on the overlaying axis to
-restore v3 behavior:
+See
+[test/image/mocks/color_syntax_formats.json](https://github.com/plotly/plotly.js/blob/master/test/image/mocks/color_syntax_formats.json)
+for a working example using each format.
+
+#### Browser compatibility
+
+All of these are parsed by Plotly in JavaScript and normalized to legacy
+`rgb(...)` / `rgba(...)` before being written to the DOM, so the browser never
+sees the modern syntax — your figures render the same in any browser that ran
+v3. The note below only matters if you also mirror these strings into your own
+stylesheets or template literals.
+
+Native CSS support:
+
+| Format | First supported |
+|---|---|
+| `#rrggbbaa`, `#rgba` | Chrome 62 (2017), Firefox 49 (2016), Safari 9.1 (2016) |
+| `rgb(r g b)`, `rgb(r g b / a)`, `hsl(h s l / a)` (space + slash-alpha) | Chrome 65 (2018), Firefox 52 (2017), Safari 12.1 (Mar 2019) |
+| `hsla()` | Universal since IE9 |
+| `hwb()` | Chrome 101 (Apr 2022), Firefox 96 (Jan 2022), Safari 15 (Sep 2021) |
+
+`hwb()` is the only format here that won't parse in browsers from ~2020 or
+earlier. Everything else is safe in any browser shipped in the last seven
+years.
+
+---
+
+## Country name lookup
+
+*Implemented in [#7856](https://github.com/plotly/plotly.js/pull/7856).*
+
+`locationmode: 'country names'` on `choropleth` and `scattergeo` traces is now
+resolved by [country-iso-search](https://github.com/plotly/country-iso-search)
+instead of [country-regex](https://github.com/etpinard/country-regex). The
+attribute name, accepted values list, and ISO-3 output are unchanged — the
+difference is in *how* a name string is matched to an alpha-3 code.
+
+The old library walked a table of country-specific regular expressions and
+returned the first match. That made it lenient (substring matches worked) but
+ambiguity-prone — strings like `'Republic of'` could resolve to whichever
+entry's regex hit first. The new library does a sanitized exact lookup against
+a curated alias table, which is stricter about ambiguous input but accepts
+many more legitimate forms.
+
+### Previously recognized names that no longer work
+
+Strings that only matched because of overly broad regex fragments now fall
+back to the unrecognized-name log message and the location is skipped. In
+practice this hits inputs that weren't really country names — partial phrases,
+generic descriptors, or strings containing a country name as a substring of
+something else (e.g. `'Republic of Foo'`, `'Not Iran'`). If you were relying
+on a non-canonical form, switch to the country's name, an alias, or the ISO-3
+/ ISO-2 code.
+
+### Names and forms that now resolve
+
+The alias table is larger and the input is normalized before lookup, so a
+number of forms that previously failed now work:
 
 ```js
-{ yaxis2: { overlaying: 'y', side: 'right', tickmode: 'auto' } }
+// All resolve to 'FRA'
+'France'
+'FR'                        // ISO 3166-1 alpha-2
+250                         // UN M49 numeric (number or string)
+'\u{1F1EB}\u{1F1F7}'        // flag emoji
+
+// Historical / native / punctuated names
+'Burma'                     // → 'MMR'
+'Türkiye'                   // → 'TUR' (diacritics stripped)
+'Cote d\'Ivoire'            // → 'CIV' (apostrophes ignored)
+'St. Kitts and Nevis'       // → 'KNA' ('St.' expands to 'Saint')
+'The Gambia'                // → 'GMB' (leading 'The ' dropped)
 ```
 
-### Incidental bug fix
+Matching is case-insensitive. Sanitization also collapses internal whitespace,
+drops `.` `()` `,`, maps `&` → `and`, and turns `-` / `–` / `—` into spaces —
+so cosmetic punctuation differences in your input data no longer block a
+match.
 
-`showexponent`, `showtickprefix`, and `showticksuffix` values of `'first'` and
-`'last'` were previously ignored on axes rendered with `tickmode: 'sync'`. Any
-workaround for that (e.g., forcing `'all'` on overlay axes) is no longer
-needed in v4.
+### Disputed-territory codes are retained
+
+The user-assigned alpha-3 codes Plotly historically recognized for disputed
+regions still work:
+
+| Code | Region |
+|---|---|
+| `XAC` | Aksai Chin |
+| `XAP` | Arunachal Pradesh |
+| `XBT` | Bir Tawil |
+| `XHT` | Halaib Triangle |
+| `XJK` | Jammu and Kashmir |
+
+These are layered on top of the standard ISO 3166-1 records via
+[src/lib/custom_country_codes.ts](https://github.com/plotly/plotly.js/blob/master/src/lib/custom_country_codes.ts).
+Whether a feature for them appears on the rendered map still depends on the
+topojson resolution in use.
+
+---
+
+## Scattermap icon defaults
+
+*Implemented in [#7825](https://github.com/plotly/plotly.js/pull/7825).*
+
+If you used `scattermap` or `scattermapbox` in v3, three rendering details
+have changed by the time you land on `scattermap` in v4:
+
+### Marker icons now respect `marker.color`
+
+`marker.color` on a scattermap trace is now applied to the icon by setting
+`icon-color`.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 scattermap icons uncolored](/all_static/images/whats-new-in-v4/scattermap_iconcolor_v3.png) | ![v4 scattermap icons tinted red](/all_static/images/whats-new-in-v4/scattermap_iconcolor_v4.png) |
+
+### Maki icon set updated to v8 (via jsDelivr)
+
+The icon CDN and version have changed:
+
+| Version | URL |
+|---|---|
+| v3 | `https://unpkg.com/maki@2.1.0/icons/<name>.svg` |
+| v4 | `https://cdn.jsdelivr.net/npm/@mapbox/maki@8.2.0/icons/<name>.svg` |
+
+A handful of icon names removed between Maki 2.1 and 8.2 will now silently
+fail to load (HTTP 404). If you were using one of the dropped icons, swap it
+for the nearest Maki 8 equivalent (see [Maki 8 icon
+list](https://labs.mapbox.com/maki-icons/)).
+
+### Legend swatch always renders as a circle
+
+`scattermap` legend swatches now always draw a circle, regardless of
+`marker.symbol`. In v3 the swatch went through the same code path as cartesian
+traces, which only understands the [Plotly-supported symbol
+names](https://github.com/plotly/plotly.js/blob/master/src/components/drawing/symbol_defs.js).
+On map traces, that produced inconsistent output: symbols with names that
+don't overlap the Plotly set (Maki-only names like `'airport'`, `'cafe'`)
+rendered as filled circles, while other symbols (`'square'`, `'star'`, etc.)
+rendered as broken/empty paths in the legend even though they draw correctly
+on the map. The v4 circle fallback makes the swatch consistent across every
+scattermap trace.
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 scattermap legend inconsistent](/all_static/images/whats-new-in-v4/scattermap_legendsymbol_v3.png) | ![v4 scattermap legend all circles](/all_static/images/whats-new-in-v4/scattermap_legendsymbol_v4.png) |
+
+If you were styling the legend swatch path directly based on `marker.symbol`,
+that selector will now always match a circle path on map traces.
+
+---
+
+## Geo `fitbounds` framing for antimeridian features
+
+*Implemented in [#7891](https://github.com/plotly/plotly.js/pull/7891).*
+
+`layout.geo.fitbounds: 'locations'` (and `'geojson'`) now correctly frames
+choropleth and scattergeo location traces containing features that cross the
+±180° antimeridian — Russia, Fiji, Antarctica, New Zealand, and the Aleutian
+Islands portion of Alaska. In v3 these were mis-framed because the underlying
+bounding-box computation (`@turf/bbox`) reported a bogus whole-globe span
+(`[-180°, 180°]`) for any such feature, and the fit zoomed the map out to
+match. In v4, `computeBbox` uses `d3-geo.geoBounds`' widest-gap longitude
+algorithm on the feature's vertices and returns the compact crossing range
+(with `east > 180°` when the range wraps).
+
+Because v4 also flips the `fitbounds` default from `false` to `'locations'`
+(see [Geo subplots auto-fit by default](#geo-subplots-auto-fit-by-default)),
+figures that never set `fitbounds` explicitly now participate in auto-fit too
+— so this antimeridian fix reaches many more figures than it would have as a
+standalone change.
+
+### Which figures shift
+
+A figure sees a visible change when **both** of the following hold:
+
+| Condition | Detail |
+|---|---|
+| `layout.geo.fitbounds` is active | Either explicitly set to `'locations'` / `'geojson'`, or left at the v4 default (see the opt-out list in the auto-fit-default section above). |
+| The figure contains an antimeridian-crossing feature | A `choropleth` or `scattergeo` trace with `locations` where at least one location resolves to a feature that crosses ±180°. |
+
+Figures that opt out of auto-fit (`fitbounds: false`, an explicit view
+attribute, or one of the projections listed as skipping auto-fit), or that
+don't include an antimeridian-crossing feature, render identically to v3 as
+far as this fix is concerned.
+
+### Example
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'choropleth',
+    locations: ['RUS'],
+    z: [1],
+    colorscale: [[0, '#c33'], [1, '#c33']],
+    showscale: false
+}], {
+    geo: { fitbounds: 'locations', projection: { type: 'equirectangular' } },
+    width: 700,
+    height: 500
+});
+// v3: fits to a bogus [-180°, 180°] span — Russia is a small red strip at
+//     the top of the whole world.
+// v4: fits tightly to Russia's actual longitudinal extent (~19° through
+//     ~190°, unwrapped across the antimeridian).
+```
+
+| Before (v3) | After (v4) |
+|---|---|
+| ![v3 Russia mis-framed with empty space](/all_static/images/whats-new-in-v4/antimeridian_v3.png) | ![v4 Russia tightly framed](/all_static/images/whats-new-in-v4/antimeridian_v4.png) |
 
 ---
 
@@ -913,53 +1032,207 @@ pixels.
 
 | Before (v3) | After (v4) |
 |---|---|
-| ![v3 sankey with crossing links](/all_static/images/whats-new-in-v4/migration_sankey_v3.png) | ![v4 sankey with rewritten layout](/all_static/images/whats-new-in-v4/migration_sankey_v4.png) |
+| ![v3 sankey with crossing links](/all_static/images/whats-new-in-v4/sankey_v3.png) | ![v4 sankey with rewritten layout](/all_static/images/whats-new-in-v4/sankey_v4.png) |
 
 ---
 
-## Sankey node and link ordering
+## Chart Studio APIs removed
 
-*Implemented in [#7873](https://github.com/plotly/plotly.js/pull/7873).*
+*Implemented in [#7812](https://github.com/plotly/plotly.js/pull/7812).*
 
-Two new attributes let you override the automatic ordering that v4's d3-sankey
-algorithm applies:
+The legacy "Edit in Chart Studio" link, related config options, and the
+streaming token attribute have been removed. The `sendChartToCloud` modebar
+button (aliased as `sendDataToCloud` in v3, now targeting Plotly Cloud in v4;
+see [Share with Plotly Cloud](#share-with-plotly-cloud)) and its
+`showSendToCloud` config option are retained — only the duplicate
+`editInChartStudio` button and the on-graph "Edit chart" link are gone.
 
-| Attribute | Default | `'input'` value |
+### Removed config options
+
+`Plotly.newPlot(gd, data, layout, config)` no longer accepts:
+
+| Removed | What it did | Replacement |
 |---|---|---|
-| `sankey.node.sort` | `'auto'` | Preserves the vertical order of nodes as given in `node.label`, disabling the layout's default y-axis reordering. |
-| `sankey.link.sort` | `'auto'` | Preserves the order in which links are given in `link.source` / `link.target`, disabling the layout's per-node link ordering. |
+| `showLink` | Drew an "Edit chart" link at the bottom-right of the plot | None — remove the option |
+| `linkText` | Text for the `showLink` link | None — remove the option |
+| `sendData` | Whether the link uploaded data or just linked to a file | None — remove the option |
+| `showSources` | Hook that drew custom source links next to `showLink` | None — remove the option |
+| `showEditInChartStudio` | Pencil-icon variant of `sendChartToCloud` | Use `showSendToCloud` |
 
-Defaults reproduce v3 behavior, so no code change is needed on upgrade. Use
-`'input'` when you want a stable, deterministic ordering across renders —
-animation, side-by-side comparisons, or figures where the input order carries
-semantic meaning that the layout would otherwise obscure.
+```js
+// Before
+Plotly.newPlot(gd, data, layout, {
+    showLink: true,
+    linkText: 'View on Plotly',
+    showEditInChartStudio: true,
+});
+
+// After
+Plotly.newPlot(gd, data, layout, {
+    showSendToCloud: true,
+});
+```
+
+### Removed modebar button
+
+`editInChartStudio` is no longer a built-in modebar button. If you were adding
+it explicitly via `modeBarButtonsToAdd`, switch to `sendChartToCloud`. Note
+that the v3 alias `sendDataToCloud` was **also** removed in v4, so code that
+referred to the button by that name needs to be updated too:
 
 ```js
-Plotly.newPlot(gd, [{
-    type: 'sankey',
-    node: {
-        label: [/* … */],
-        sort: 'input'
+// Before (v3 — both worked)
+{ modeBarButtonsToAdd: ['editInChartStudio'] }
+{ modeBarButtonsToAdd: ['sendDataToCloud'] }
+
+// After (v4)
+{ modeBarButtonsToAdd: ['sendChartToCloud'] }
+```
+
+### Removed trace attribute
+
+The undocumented `stream` attribute (`stream.token`, `stream.maxpoints`) has
+been removed from every trace type. It was a hook for the Chart Studio
+streaming service, which is no longer reachable. If you have figures
+containing `stream: { token: '...', maxpoints: N }` in their trace objects,
+delete those properties — they're now schema-rejected.
+
+### Removed data-source (`*src`) attributes
+
+*See [#7829](https://github.com/plotly/plotly.js/pull/7829).*
+
+Every schema attribute ending in `src` (`xsrc`, `ysrc`, `textsrc`,
+`marker.colorsrc`, ...) has been removed, along with `layout.hidesources`.
+These existed only to interoperate with Chart Studio's data-source
+references, which is no longer reachable. If your figures contain any
+`*src` attributes or `hidesources`, delete them — they're now schema-rejected.
+
+### `Plots.graphJson()` signature simplified
+
+*See [#7829](https://github.com/plotly/plotly.js/pull/7829).*
+
+`Plotly.Plots.graphJson()` previously accepted a `mode` argument that was
+Chart Studio–specific. It has been dropped:
+
+```js
+// Before
+const json = Plotly.Plots.graphJson(gd, opts, mode);
+
+// After
+const json = Plotly.Plots.graphJson(gd, opts);
+```
+
+If you were passing the third argument (typically `'keepdata'` or
+`'keepall'`), remove it — that behavior was only meaningful when uploading
+to Chart Studio.
+
+---
+
+## Mapbox traces and subplots removed
+
+*Implemented in [#7860](https://github.com/plotly/plotly.js/pull/7860).*
+
+The legacy mapbox-gl-js–based traces and subplot type have been removed. The
+MapLibre-based `map` family that has shadowed them since v2 is now the only
+map implementation. For deeper background on the switch, see [Mapbox to
+MapLibre migration](https://plotly.com/python/mapbox-to-maplibre/).
+
+### Removed
+
+| Removed | Replacement |
+|---|---|
+| `scattermapbox` trace | `scattermap` |
+| `choroplethmapbox` trace | `choroplethmap` |
+| `densitymapbox` trace | `densitymap` |
+| `layout.mapbox` subplot (and `mapbox2`, `mapbox3`, …) | `layout.map` (and `map2`, `map3`, …) |
+| `layout.mapbox.accesstoken` | None — MapLibre uses open tile providers |
+| `mapboxAccessToken` config option | None — see above |
+| `plotly-mapbox.min.js` partial bundle | `plotly-map.min.js` |
+| Modebar buttons `zoomInMapbox`, `zoomOutMapbox`, `resetViewMapbox` | `zoomInMap`, `zoomOutMap`, `resetViewMap` |
+| `scrollZoom` flag value `'mapbox'` (e.g. `scrollZoom: 'mapbox+cartesian'`) | `'map'` |
+
+The schema for `map` mirrors `mapbox` attribute-for-attribute (`domain`,
+`style`, `center`, `zoom`, `bearing`, `pitch`, `bounds`, `layers[...]`), so
+the migration is usually a rename.
+
+```js
+// Before
+{
+    data: [{ type: 'scattermapbox', lon: [...], lat: [...] }],
+    layout: {
+        mapbox: {
+            style: 'open-street-map',
+            center: { lon: 0, lat: 0 },
+            zoom: 2,
+        },
     },
-    link: {
-        source: [/* … */],
-        target: [/* … */],
-        value:  [/* … */],
-        sort: 'input'
-    }
-}]);
+    config: { mapboxAccessToken: 'pk.eyJ1...' },
+}
+
+// After
+{
+    data: [{ type: 'scattermap', lon: [...], lat: [...] }],
+    layout: {
+        map: {
+            style: 'open-street-map',
+            center: { lon: 0, lat: 0 },
+            zoom: 2,
+        },
+    },
+    // mapboxAccessToken removed — MapLibre needs no token for the
+    // built-in styles
+}
 ```
 
-The `sort` attribute is not honored on circular Sankey diagrams — those
-continue to use `d3-sankey-circular`, which has no equivalent hook.
+### Built-in style values
 
-Same data, same code — only the `sort` value differs:
+Every built-in `style` name that worked on `mapbox` still works on `map`, but
+the tiles backing them differ — visual output **will change** even when no
+other figure changes:
 
-| `sort: 'auto'` (default) | `sort: 'input'` |
+| Style name | Old (`mapbox`) | New (`map`) |
+|---|---|---|
+| `basic`, `streets`, `outdoors` | mapbox.com vector tiles (required token) | Carto Voyager |
+| `light` | mapbox.com light | Carto Positron |
+| `dark` | mapbox.com dark | Carto Dark Matter |
+| `satellite`, `satellite-streets` | mapbox.com satellite | ArcGIS World Imagery |
+| `white-bg`, `open-street-map` | unchanged | unchanged |
+| `carto-*`, `carto-*-nolabels` | n/a (already open) | unchanged |
+
+The three Stamen styles (`stamen-terrain`, `stamen-toner`,
+`stamen-watercolor`) are gone — Stamen tiles now require a Stadia API key.
+Users who need them can supply a custom `style` URL.
+
+### Custom style URLs
+
+Custom MapLibre / Mapbox-style JSON URLs continue to work. The
+`mapbox://styles/mapbox/...` short form is no longer resolved, since it
+requires authenticating to mapbox.com. Substitute the full URL of an
+equivalent open style, or self-host the style JSON.
+
+---
+
+## Minimum Node.js version
+
+*Implemented in [#7861](https://github.com/plotly/plotly.js/pull/7861).*
+
+Plotly.js now requires Node.js v22 or newer. The previous floor was v18, which
+has reached end-of-life.
+
+This only affects you if:
+
+| Scenario | Why |
 |---|---|
-| ![auto reorders sources to reduce crossings](/all_static/images/whats-new-in-v4/migration_sankey_sort_auto.png) | ![input preserves the given order, crossings and all](/all_static/images/whats-new-in-v4/migration_sankey_sort_input.png) |
+| You build Plotly.js from source | Contributors and custom bundles |
+| You run Plotly.js in a Node.js runtime | Server-side rendering via jsdom, validation scripts, image export pipelines, etc. |
+| You install via `yarn` or `pnpm` | Both enforce `engines` strictly (`npm` prints a warning but installs) |
 
-In this figure the source nodes are given as `[A, B, C, D]` and paired
-one-to-one with targets `[Z, Y, X, W]` — a maximally-crossed input. `'auto'`
-flips the source column to `D, C, B, A` so the primary flows run horizontally;
-`'input'` leaves both columns in the given order and preserves every crossing.
+Consumers who only load the pre-built browser bundle (`plotly.min.js` or a
+partial bundle like `plotly-basic.min.js`) are unaffected — the bundle runs in
+browsers, not Node.
+
+If you're on Node 18 or 20, upgrade to 22 LTS. `npm` will print a warning on
+install but won't fail; `yarn` and `pnpm` will refuse to install unless your
+environment satisfies `engines.node >= 22.0.0`.
+
+---

From 2ac82b0c7df3333d76e40ef8fab10f77655b4b4e Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Mon, 27 Jul 2026 15:05:09 -0600
Subject: [PATCH 12/25] Add section about Sankey direction, fix some incorrect
 language

---
 .../2026-07-17-migrating-to-v4.md             |   2 +-
 .../2026-07-20-whats-new-in-v4.md             |  90 +++++++++++++-----
 .../sankey_direction_forward.png              | Bin 0 -> 30374 bytes
 .../sankey_direction_reversed.png             | Bin 0 -> 29783 bytes
 4 files changed, 67 insertions(+), 25 deletions(-)
 create mode 100644 all_static/images/whats-new-in-v4/sankey_direction_forward.png
 create mode 100644 all_static/images/whats-new-in-v4/sankey_direction_reversed.png

diff --git a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
index 96e9b2dda..5e1c7b378 100644
--- a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
+++ b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
@@ -203,7 +203,7 @@ Figures that already supply view attributes render unchanged.
 
 | Change | Detail |
 |---|---|
-| Marker icons now respect `marker.color` | To keep icons in their original artwork color, set `marker.color: 'white'`. |
+| Marker icons now respect `marker.color` | To maintain the v3 behavior, pass `marker.color: 'black'` |
 | Maki icons load from `@mapbox/maki@8.2.0` via jsDelivr | A handful of icon names dropped between Maki 2.1 and 8.2 will 404 — swap to the nearest Maki 8 equivalent. |
 | Legend swatches always draw a circle | Regardless of `marker.symbol`. Selectors that styled the swatch path based on symbol name will now match a circle on map traces. |
 
diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
index b976de98d..ea727a221 100644
--- a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -25,6 +25,7 @@ v4](/javascript/guides/migrating-to-v4/).
 - [Share with Plotly Cloud](#share-with-plotly-cloud)
 - [MathJax v4 support](#mathjax-v4-support)
 - [Sankey node and link ordering](#sankey-node-and-link-ordering)
+- [Sankey flow direction](#sankey-flow-direction)
 - [Geo subplot zoom limits](#geo-subplot-zoom-limits)
 - [TypeScript types](#typescript-types)
 
@@ -94,10 +95,12 @@ of `1` (default) gives a head about 3× the line width.
 
 ### Coloring arrows by a scalar field
 
-Pass a `c` array (one value per arrow) plus the usual colorscale attributes
-(`marker.colorscale`, `marker.cmin`, `marker.cmax`, `marker.showscale`,
-`marker.colorbar`) to color each arrow by an independent scalar. Without `c`,
-every arrow uses `marker.color`.
+Pass `marker.color` as an array (one value per arrow) together with the usual
+colorscale attributes (`marker.colorscale`, `marker.cmin`, `marker.cmax`,
+`marker.showscale`, `marker.colorbar`) to color each arrow by that scalar. If
+you enable a colorscale but don't supply a `marker.color` array, arrows are
+colored by their vector magnitude `|(u, v)|` instead. A single (non-array)
+`marker.color` paints every arrow that one color.
 
 ```js
 {
@@ -283,6 +286,56 @@ flips the source column to `D, C, B, A` so the primary flows run horizontally;
 
 ---
 
+## Sankey flow direction
+
+*Implemented in [#7870](https://github.com/plotly/plotly.js/pull/7870).*
+
+A new `sankey.direction` attribute controls which way flows run along the
+`orientation` axis, so you can reverse a diagram without manually reversing
+your `link.source` / `link.target` data.
+
+| Attribute | Default | `'reversed'` value |
+|---|---|---|
+| `sankey.direction` | `'forward'` | Flips the flow along the `orientation` axis. |
+
+`direction` is orthogonal to the existing `orientation` attribute (`'h'` /
+`'v'`), giving four combinations:
+
+| `orientation` | `direction` | Result |
+|---|---|---|
+| `'h'` (default) | `'forward'` (default) | Sources on the left, targets on the right |
+| `'h'` | `'reversed'` | Sources on the right, targets on the left |
+| `'v'` | `'forward'` | Sources on top, targets on the bottom |
+| `'v'` | `'reversed'` | Sources on the bottom, targets on the top |
+
+The default (`'forward'`) reproduces v3 behavior, so no code change is needed
+on upgrade.
+
+```js
+Plotly.newPlot(gd, [{
+    type: 'sankey',
+    orientation: 'h',
+    direction: 'reversed',   // sources on the right, targets on the left
+    node: {
+        label: [/* … */]
+    },
+    link: {
+        source: [/* … */],
+        target: [/* … */],
+        value:  [/* … */]
+    }
+}]);
+```
+
+Node labels stay upright and readable in every combination — only the flow
+geometry mirrors.
+
+| `direction: 'forward'` (default) | `direction: 'reversed'` |
+|---|---|
+| ![forward flow with sources on the left](/all_static/images/whats-new-in-v4/sankey_direction_forward.png) | ![reversed flow with sources on the right](/all_static/images/whats-new-in-v4/sankey_direction_reversed.png) |
+
+---
+
 ## Geo subplot zoom limits
 
 *Implemented in [#7371](https://github.com/plotly/plotly.js/pull/7371).*
@@ -745,16 +798,19 @@ accepted.**
 // Before — tinycolor parsed this as 0–1 fractions
 'rgb(0.5, 0.5, 0.5)'  // → rgb(128, 128, 128)
 
-// After — the underlying library reads them as integer 0–255 (truncated)
+// After — the underlying library reads them on the 0–255 scale and rounds
+// to the nearest integer
 'rgb(0.5, 0.5, 0.5)'  // → rgb(1, 1, 1)
 ```
 
 Convert any inputs of the form `rgb(0.5, 0.5, 0.5)` to `rgb(128, 128, 128)`
 (or any other supported color string) before passing them to Plotly.
 
-Mixed-format strings where at least one component is `>= 1` (e.g. `rgb(255,
-0.0, 0.0)`) continue to render correctly: the new parser treats the `0.0`
-components as integer `0`.
+Every numeric component is read literally on the 0–255 scale and rounded —
+there is no 0–1 fraction detection. A string like `rgb(255, 0.0, 0.0)` still
+renders correctly because its `0.0` components round to `0`, but any genuinely
+fractional component rounds to the nearest integer rather than scaling to
+0–255 (e.g. `rgb(200, 0.5, 0.5)` → `rgb(200, 1, 1)`).
 
 **Numeric color inputs are now rejected.**
 
@@ -812,21 +868,7 @@ for a working example using each format.
 All of these are parsed by Plotly in JavaScript and normalized to legacy
 `rgb(...)` / `rgba(...)` before being written to the DOM, so the browser never
 sees the modern syntax — your figures render the same in any browser that ran
-v3. The note below only matters if you also mirror these strings into your own
-stylesheets or template literals.
-
-Native CSS support:
-
-| Format | First supported |
-|---|---|
-| `#rrggbbaa`, `#rgba` | Chrome 62 (2017), Firefox 49 (2016), Safari 9.1 (2016) |
-| `rgb(r g b)`, `rgb(r g b / a)`, `hsl(h s l / a)` (space + slash-alpha) | Chrome 65 (2018), Firefox 52 (2017), Safari 12.1 (Mar 2019) |
-| `hsla()` | Universal since IE9 |
-| `hwb()` | Chrome 101 (Apr 2022), Firefox 96 (Jan 2022), Safari 15 (Sep 2021) |
-
-`hwb()` is the only format here that won't parse in browsers from ~2020 or
-earlier. Everything else is safe in any browser shipped in the last seven
-years.
+v3.
 
 ---
 
@@ -912,7 +954,7 @@ have changed by the time you land on `scattermap` in v4:
 ### Marker icons now respect `marker.color`
 
 `marker.color` on a scattermap trace is now applied to the icon by setting
-`icon-color`.
+`icon-color`. In v3, the icons were always black.
 
 | Before (v3) | After (v4) |
 |---|---|
diff --git a/all_static/images/whats-new-in-v4/sankey_direction_forward.png b/all_static/images/whats-new-in-v4/sankey_direction_forward.png
new file mode 100644
index 0000000000000000000000000000000000000000..e7e9ae390def360d1310e5287860e5b26676c673
GIT binary patch
literal 30374
zcmY&=1yoes`?cVRAfN*%AV`-=gNV{1or(fOmw+&IcL*pQ(v3(64BZ{lor97RLkdVY
zd}s94|L<FC7P78)?m73w^X$E!eF%7=Ac=p2?8cQVSMa5!#FVaF!GvA8f)S351+Lie
zP{v)k0=*(F_UyG2#?NV-ItFp~%kwq8*$?g?^sW;az6=%{^$OH~^o2B<RQ}P8FP-|W
z44bF#{L}npXz5=b)%vwciWxu_LQA$z8!W#zeC6JvbhTOPt#|CNKTL8RczW0ql(0FX
zrKPo>vzBXl?lI<WEEs<&N)7q<sgcoD>GGt3Vxm8Tj*yR^prmG)1TY^h&n|atUy(l_
zDnkFJwXZVLF`{YYkdG3-FE;HF_%|g89aP)?y{#!6+(uTeZ%g}s&u5gN#)Run*(m>a
zliV%uDSK*cF<pEy9)`&O+J$2Jh=JR}O_`nXy`d{u-Wdew{s=Nby~k`@tDpUAK#mUT
z%`;+JM~;#w`}bV~bgM*)3h)2xEH>T^Z;x(ch>Gx-#17%_7X$CcaT`Kg^gf;Jl|K~w
zUmJt0;8mw-<L&;9hv*MQaNh-lHu3-Z0a^kb{uKUakbeKvq8~KI%nM?WRr=Qr8V-5z
z%`6-@rpoj4El(ZoqZX2wYTIQ8LU)<@vme)m@3Xsp?;)OAPjTIRQ0Tq^?<w@y&%4%<
z1z(=MJfH31pV<ywtvP>pI%C~IVPAhfaCtWH&cH$8$(--bq37kH;eg;F%a-TmDFs>0
zuen>ERdrkLTN*D48c%B*nLki@9KD;R+nDmaJV)6Vx@x`jq)WC8)pABf^Na_vH&i_x
z-9DIc-D3Sf;Q({)gKNL4ob^1d^jtrhP@wZTU)N#p=2vkuJYR3TSl_w4n7t%tR`1`Z
z^JYV>ZdiJr>Zb;DP37L@-K^W~w`Q^(Q&t@tC=}A>k49DzbzQ^7?o}^}O@_u@@y^Zd
z&PudUSJ8Gx;b;mL%i<{&x{T!!S34d2{BHO;<gxnV(Q7K0NoMq#MnTnl;675ADb>y9
z>1NeJ_v~5UY}A&=VXfii`JtoJ%GVprh!^TlgJ1tZkCS1%VN8zSiPUnf_0Jxi3!A5>
zKTCVA3;pum$+vXRt6OAXUzI2cl3(z;dh>p)mV=tf#n%N^OJ~{RCEiB0g8GArC98_(
zQa|=a6bmOOsqgf)ZUr!<+@C#a=j|qGJZdYMc9@KQ#v<9s5!SR8n?O3~1|>>88O`n<
zNjWHcz}!6Gd9l0m%^-}`rm^v?r;+6YrOOI!NA^k6uq?Y)jJj!#pKqHVi8ica%BE-M
z9Z6jp=^NfDtFJlz$g-)hDy12vZvVr^^@7@NFp-`l@0`0BV()P(@ZKzO5!`Yf$h(dg
z>CJ<LeJ1Y;jmN@3HEcvU%(@?ztmWp#5Ge{2pTG9Fh2srIs>EX4=XKJgWn(>dN}D}W
zEgR8zabj4FiXpGE*(2J;Mp%!&Z}v)@17iZ;SUUdTdGujtD9pp|Q~Z5dzh@U?g&y|K
z$2~gQw~m%mJugHZ^=Ow&Ph&lgV|Utl8;TWr5HXW2KlMI!nhR$PwAr=aHD-CT+jx1}
zXb5_fKcYv&$#0=x6CYpB+nAVtJ>Ycc2l5_#w)@cIbVC)Jge{3K^hvs)jPqiIq-mvm
z9>3i2;z;lE^p=O?cY`p&?g!aPN;*9!djX1W`rdg<X+Ad}j%(V=n_PyOBt(D6NznM<
z|236-sgo{@<(9xN5qBNKqv6<w*E*Y1vwgPGW5O4E13tHeV72e9n){p!YJ`&uc;)Z*
z^KaGBT56_rpY=O7l%CC#G=5nKKBT(3Vw#t)QUFG0C+zYl%$~`xC|bw6M<!vRYZjk(
z>O~p(h9cR~#Km@)XVmCB>RFaYw*>bF-x-7noxIh$b$Oh6sYb=WjwtQ!5Wd*nIT>$k
zu;8_Hotz{deMzA=BkbgHGLl-*;}ukM^wU_Ff2;TGQju>pV}b!`6<z5NF=`d(*_M83
z$^=;r(%wt=Q?My@2|bvA7w&YcHk8yY3vNBIUGCSqudr)?IJiulJ<IxGzYxM3v*otT
zZ=bk5S$=encObX3JHu>E%h|GiUnP4z?Si8{PiSx_%s7b$ff{_LwIOk8e?`Nj?zqqL
zptLuEC(k2GL2!R`=hxR;;~iORR0EHA3tYzA1@lr*r<REmitL6NJH8rPZ>&ttUN}sL
zYM%_pA~lHn-e3Qeo_aRfcs^N^yk<KYOJ}E)#aNHbUzVKy;+j5RzvXT@q@cdgc`CWQ
zznz`zpg!Hv{kdTgSLaAHp5M^|KI(U{Ut2H~mgCyI#rSb~(XsJVYr0@sCvh}p;`CDC
zw1;tes3K_Li{dD;=B480p5nf3%UW%fjejZ!pEovQ=sSze`>s*yRhm-}Az{7#g3$a@
zJ=!L`eP*3wnWsx}27%ri&#6vcuwttd(Z90*OMN~mG}V7_h_p<7f%RKz<#RlfJ-*Il
zhY6FJ2ql3stnR0_OQW~)yw_Z3Pql|Q{nLoXBFY@Gz%+*Sl=QG^#6GJ#uxh)bI@;27
z<+#AHK5ykmLG5OZ&DnNGr6k36<+Ck+y3qSOCW8}(v067&u2VYcK3z_-HTAat)qFiR
zH#g7#q7xYo-=20_2w4|cIeI*4R@!py3msvMj>oZjneP0_(gZSJp-r$qWtr?Gukj>r
zLi2Lj^J4khGE$+gx?ONuvLTFrvubBATezNBGgimLnF6)lK~>04nT(S9WWNznhE#{=
zmo#IMk791IU(B<2zXFlynzPX{x#dOK1D_r3U9k_(w(kx&Ntol9P@I(uo8P9IPwzjf
z^Tf6}bDVKrc5alR`4u(xqxoaWM#UttPrEpY*6UQui)y2kBV{)8q!+v#{D)tuE{g8C
z?+w|XuZ0T|K~!qL5nX;C@TicLz?;DAp(N2GYUX}UPsoQv<jjt#>eRdaG@yc~vwTZ=
zZ25yc?;P%!a?M^(cU1c<=8B$ia<|aw&sTUH-JkMVEc)W$BqV$I6A?~Ns<(tMcZE;Y
zuA2wli7_k{;<$GC#dAZ6|3JXCV9_VK#fu$x!922Hl|C35x@Y{&m93mT{dKL`u)x}v
z&!(|_DHC%@4NEOWQ_s`MS>#K;2d^lKH>ha)&i4`-y)9iv5>1P1XX|iK=9SYGFU-u<
zQ`eFjPQstxe86bX?&C*WarO%#w5~Sr@Ldf_%H`QIyZ>DL*v({K=Wif51PW!BU#dPf
zpXJtf8;n&}E|>DGrXJ#SAnqu($IQ2k(3v;2Mv*SWJmm=!fglC2lP@eCN*6-;iG9kS
zJ!dlX;)>%jS!q=>vs+ouuhgzznb37u&5V8ga*dVO?`}=MFS*}(=MQ6Q1YOy=0rk)}
zkt(H3wxE|AYQVYQcFiw<kA}GTcjo4UP+TjPlycUU>G2dkUsVixHcLHX<J4SmtwY1C
zSez!b)gV*1o_mnZ|51CWS|-MO<tyAM!?xie7cVsihe`8F{n_9Poy&cl_0gyRj<&%o
zX>$BOi=MM~=H})u*qwx(T92%>vVME?t>m_hs$`as#z>2f<X3@$Bt9+Cm0s=v#OJQ;
zvryvRf_4Ah3r;9YaVz2OfyAX}-SMkbg#8*O(J@VlT~nVH-aRb*4vlLuH<P<Or|rk{
zKMNgJ53u_B9b{YJnRUwqj}u(%-TKtGqi;2|nW5)pWZo9F-|?d}fzA@)?O9Vc1C1*+
z9w<1JJo(_nQ&pC73ewW+Isv^GzYr!@Q|@eJ@}yLhR2|HcHM&y?`(zq_=YCrsz(t@o
zY!NowH`}eLtlV6gxEdNA<FV3kx|uhg>fEqL&d9u0RBcgbUQ%sgt${MLlw>pm197R0
zi#3qxGT1IhnAxE(+gaN0THye??9#%}Ki+V_^KvbqWxo5hq}j3Lbj^&Ic<l~L95qxf
z<rZ;i%!*&;tJJyph0Vt%i^*?K{E$`2n?wgGB<E=^90BFM@8aOYFGzyc*%PY_%=zb@
zAor7#WRoIr#B@V?4O>4`KD@fiBz)X8ZyrQIS59GuoG8->@12;uuIuBH$B->8^I<^T
zC@a&}B-GWacPH^?&Qpc^aRKU@aMtkt(X_E7$FrqG%L4w1CD>_<h-rQ7uCnqSlSv&-
z4j4gv{<fWz*d$}3S;>#0GxNstgG_=nv0F5HFSMX0@AzBSUZw0rP3(*%Kt7==cPr$f
zmESA#b90N5Iu&;{nE2JHRa(~{RW-U+;D!(FNU{)J%U>l@S}V2YA%N{HKRJYO(hCtR
z#hpjIv%_cG*m!*|aCtnSvqHELn)!3!;^zP{UuZN5B{AQV_FLwoX#>#{WFhvtiRKj#
zAUf;Y2Ng_ILGa7`amNxxsJ_GxdqU52Ybypb{4yeWgSzqjlJ19Xw)^n|Zdux`Q`+Oh
z<d%tc@=VX1CnqBw=iqmaNSUm#gVmbfp1+)W+-pp1KQR1VI$pi7d`tbDN^ijtZiVNA
zG+2|aeJhw%$XHkPOFhi7rqI*Oa@KaqnWm~e@llkg^|>LDBO>1}*VHW3Kr7Xj2yh3U
zn+_1-p8f=Qfm*LyyqQKmgb%lXx0E&p+S1YcHbbLKSabfhvT}xABTvza)hDQWeg`>c
zd*8RU60S+2LT6atsNKU5|6=XHU)=ry<CML>>>BtA4{Wi94h-ndkr?Gvu~hnLJcS3I
z08+&mrOiFI*Q$MDYgXsYVM@Y2{3SQnA)n{aMh>Q#OzMPkENk+kNmlskw98BQ3i)i`
zezSU+IJy3DOS)J_F=Mgj(@mo5SXqpgd|F6Vq{4c6RE`Oi{JqJDHSaIh78wUaY%#6m
ztevU0EQkvE!2*2KzAd9kZIA6F4b4*$;|!6h;#O-vn2!%e<&c!Mt93BkLdZw_)p9~a
zY5<l>viK|3^2D><)JwOagDT5v)xw68wQDaas0O%8f3&py1kraY=!k69=G^b%#pPJH
zx48OQqD4)YQL$kzUHRFFz~Sb!P1Q^}eam7qw=z}S;lSJTmbzE_CD$jnu?|fdvvP?y
zFQd_O;7Ue!9;3i?PqOB52csn5bV+A+w|m!+_+|~qOMX2Coa<birwt*YLC3KHv2F0A
zN*H~O{e6UL>*RpPLFu(+RNF0&lZYu5xy^ptbr`&v^~(Zvkv4#J{5<-)eY!UqPd95x
zp3biJHsli9FL$xO<W<tf|7d~48%&<*;Q4%wg6`8d56Y{_Z?pA_t0`k6c4qFuea(qH
zttYpa3Ui4KO~W~Q4DogAX<d3l$EbSJaJ&w>)VoU<6xU|e?-l3-jaQpgh4Ys;@%Vg|
z+VFX69j5S3+NZhvoXn6k=VEdzTd;ayexmWo#xwGw{-E{ln7pCg?T9e9H=n*J^Q2Z|
z<nH^fOLiN;liD_z2c$%Y?KKO0Tg9%%X4^^Jm>SpasJuC9+a&&N^jWrfNiO3+Tj|V{
zV}@I<&c<hFa^A$!zgj@UL}fqkc!+WqqeAIe!_Tl$-XGrH##%|*ez^$)mWaJ*OY3tK
zY@ByFW8^`{Qi56Sb1>5H?)BBw+w0YbHp_DnYjbh#X2M4)mEc}UiE=-3OBI@2Zm%cQ
zHPZ>QQOtMgtN9qazD?fN_-R2A%d3iqhky^0vXYur$4w0A*mN;$eBit26E}QsR_y4i
zO%WNs6ZicRfZzk$R$bjC%C`!k6$}qqX&?K*Lq4bAh4Z113qg~Gxw&P_wfnqAL9(Cs
z-70rJFjr2ndu#`#pDT}@^-ngOAcX=7jOr;Wc5>yd-B;YU7ayDS&AvTdlTzQ<@JTEg
zBjcLb&+o__^U!fF{ie-t9s=L?Sl`+%yF{-4)VN%Ds;{?H!23;AxqOhkd7g*1t{&g{
zW*LpO1nxwR?YD^vtoiOqm(T8%@|SwaNU`VZ^%9fD0mk;IH6_YzKJ&=Pxp^VXO+?GY
zm)Q+(d!%!uKXMuIef)Z*4!2VL#KK!0MrxMjjb%Bd#k}()F^{~<h_!~1GJ$ar?D?hP
zwD&YdlFgo~k0h9!62KO|SaUZBpUvGWSBrC=Xfazd!iRAoiJg0bG}?QAf(#&C><~C;
z<5AKq`i6oFerx=lU4VdP>XB3C=?yHQRIaxaS6HARI(y&_suL$8VaLVPW0-F&MdDZ0
z$n60Tjm@H?T%Q=~=iJpe8t{7<w(}6y*_}JjceV0vIqxuJ*<HQqr?N5K&7hFbo=GpG
zq|f+k2)ovVXJQTbZ~0zW_7Ef)eHczG7|cIg^{*ymtNQUyU6%(%Q^dg??mu#`QX!E4
z#p$BZn>oIfG@rm`L;yDu*|c=+iskF#;gdJ-PvPqZTD-$gG2dM=6RbR(aUGw9o~}p=
zt9!P5Ep2UC($3#*AGy#dEVb0nxR*j6Nj<>r_=)T3EX2BuDCVsNuResG*z~F*k!41{
zD`{tD4yF1vT9SM?qPa9VP^8GkR(`s))0vS)Shv_jOg!7%hD$S{<RSlIS*)=@?1_qH
znTt?c^MLI0sfq^oY<8&J?Xl=5$x+gE$h7GqXzr{1LU%RMIU@QAj36WUS-|G56|6@_
zM5a<JgPm<!;iRW6bIy(FUK=^9T*bZ5nfyed0}l-uZ<q2LJ|eZwhdomGRuoG5y7$Xe
z^CTOkHfGBtjVAjP3D%=!Ch{t0JU%2d!HeP20*P!Btzd)AKJ%RCjtw{kW6tV9beDbG
zLlu0DfXP;nzOK4okJ9f8DwC|uid^7(b;y)bN6g-cMNQ#gTOTUkq4>l3Q<Jlg6L;F(
zUv}@NGG|V9SToVQ!27E@u?pF`*=PXQs^*w1d}{UEmdb^j{<CvaS9y)slm!9^>^B>&
zoZen98`oM+h*e(VuGA;5xG^;+Fqo%0?cS(%(f5mTU>fJO_ILM5eAf6>BI*khv4l?^
zufZ4(i2z)KXh5Z!&*XBx0?S;QoYqB-vCLY9TQ1kM;aX8ZVRA{CHO8q?gc~$&XT0^U
z3B2UT2w{q94_4i^sa9@+(wiSMbDtvD^A$Ov$|r2ZX3k$<o%0rSZ<loi*qE?pmm}7^
zonoknSe@U_*UjNuei0Ua?)9{=F?@E(jmgk-zQUsZ*?Pn5<;CIp7Gm|59CDAJ(L3Lo
zsb))Ua6JB==~qUP1$kN5sCL-7A(IJP=mN~d?(;o^OyS;T{bn-B4YCY-h|vgHU8S`;
z>s7e{Bb9z!EXQSc+njxTvJQKejmnsY=JcoiJol4T;6y}K@v&j5kGJiH`Q(WoZ=;6h
zm9JV5Wq)6*WAU=^2rK9LvNCwFAbj!pLIE0Kc*WS-w1C^cDjTEb>0|ZdBoM8jE=EDV
z5pd2@j>%)jBCMLq0r{gVspXt~)YPHg{p+Izhs7cth!BIm(pg9;FR}18LeF*v7rW1S
zGNSuORhrOf(0Lc6(3w1LawN{|B12L$hiLz`GH%e-bdB%Zw^gZ)@DD<9wWp|s)THnq
z&12JT+tuM{t1=;`$W>dS!+)8CG4{__Ak0XeQq&g+)wHL_A194ySJjorJLru_pN_w0
zS+T6YPGd>v>uvmAcMne^XzZjnA1GP-v!QRa2vpU5KQ)K>WlG!9YscVzxr!7um)1n$
zS(sjpoqcu3P2s)0)LjT_kWH;kV>eBR_^{Vs_%2(4C8lb5xz|KQxz&@$%iVPpcqqx!
z7|Zii#l>EJWj@x(s{Bv6x#_n|)?N#L7Pcf&-AOmE)P|=@ifHd;dxYKgSEW@r9m|S(
zRX21Zc`i31(Mpt?TY8~1#rS9etJ2Z7*MTLp-?o}LQfOw2F<2#Z$*tlu5m0B7`(7mL
z$sFcjC3j1;z`xu`Y{A3BFdyQrfU)tN?{ziZwulNY=`S`-d>c&2@ZmW%<h>UlUC`I_
zF!7>rRb7)J%7AD+#L-jU*AT394n(Ywvwrfd$QviZ__Fsw@Nn_>RY_t>)sG;eX#)U@
z?>k?Uf9$HgyL3WRQ03R|;_g~<*u77~@e&j1NuW+t@A0BwAqADY=s^`Fz?2FETq3lr
zOk7Fx#8}I_93RP{#?1*4mm&C16i(YhKhymVgU^3jZxM(0*_tO%j?Z-@yY&8v(_TOi
zCo8%k>j3&+^NiZ$w|H)e{%(w=(k*Ya><m6}-asWb(#>@I+$l}>S0~rC15f*0+7<ub
zP1xSew1d3WAx&$Exl$7U#Oe2bU{s1m-*o?$$ET^oAA$d>5v9h=V<wH1`r8o^>@zAL
zty~&J)c=1PHUlPe$p0$;a%q<kl~~-k#edHi)y)OnmFL->V*lMUU1}Wq5gHCk(7A<A
z(N+H^bq`{I25wR_$bdF^vFSs8zt~gsiz#SjXZ*YG6<XB~6meX5{6DYCffoNI1Q}xg
zyKS%#^0ANrTnxFw@Zo>D!UZ13_?&(Gx2*qPBcIR{Wv85g>GxObm*WLJSuOCMYW!E2
z5W(KN11>h?hQ49^H^8LWy(F-&FFr=m{JlgCIq?-yy@s5sw(T*=PDYMV_X+7moBb(y
z$Z>j4u|XtgMaYwo%PybuFxP*U4zQsmhi;7P_XeY>^U+!zDww;UR5d)zw*P5%lIvzQ
z3drNkKw0&u{?&rpgH~PG8jj`xo{Ei<Wv?&O^f*SL0+|c$t7<zNR-dfp_3(^qzCw%B
zHh`W+lUr1MngXg43Xnjy%4r9UY9KcR-lzu|xaa(ERtHGVpLSM0hs7|ZIO%893>5#j
zSV&=*VZs+qg6((LgPq%j4AP1R<KCJ*k|1LaiEmdhSQ*=GS2D;g9wUV#c$UaqLz>(5
z4N8i?lbR!hTvHrKx1K1H*R7K?#VVdH1{U}_Qn=bggjuM-RIkMZ=NGlyFpO4KS(OQo
zdDKDvD7b^t6=88NOkhXK`DpG#4_c3<bo$|~es9`w)?M778o+b-klnbJ;~3`J!K7tj
z+h~5}j5=-}U=umS>SUo3pPS#Zkab@p(R_hhRoc&&N9_4f!e_|o5hK1V-N+BLU`xxo
zYMMlrbJ`PD*R}4{6L&;2c-Oo22G}_!kl+XH#0J5|?QsS_IkD~r1xvRx8jJ#+PKBH@
zSgW1G;BK*j?3Mo+1}T_y(BMb5AwxWSDuY~CGK1;aIN6M@uwvLua9{B49n;<vDT@4>
zAr-?7^OPYls{xC82zU)!QG3mIj?@v6N2DQ=2E#><xbQb)G%RxR^<Fo$=R}wyMg<rY
zn|blouZ|CrM=&<5_uhV_8=~^uzEE!|zU0r^j7l#YUtT}OxohCfIhUJPkXz5ue!~EZ
zb5!mq<nLRI@Wqfu2Ftg90c$7wu>fi9R1b`JbD9R~T}~SM%31v@vWaI;A|oE(=}YhJ
zUNV9EMnt}(FPEO}SQW>`NBA!{)BMUXaNvkG?5zK@aflVY_TP(3>X`4yJt26;B6DKr
zUMr-nQ#dewNThP&WYCiAIHRTsM+}b3vdgLv54b-x0Q;R`gK{d!YsboY5S#hdgHPgC
zJhyVxLfn^hjkMDHp07?&zIh=1r?}QjC$eW1v6@(o@~3C3<Q@<x)z)um$tZm6%$T&-
z2in`ad9v*6*m-#_2ZB;6JX_Y8J8!#*>-uhNA_FILA`O8KrBf+m3&Oe6{szKCt6TIV
z4mv7+qSIw1cqS$iKeeV&y;!vjORd^CLsr`K^d<9GdOTa}VoJToNBm$g9mE7;L$1%E
zP@NgVyE&1%35-p>B}b<L?6e`U#Fybp-{$DUmHb4mL;Pt91lXR^1~Pd`dU?@iNF*c?
zYE#fB-+!(ELQ*HQQ%M_Llf=3vtRb$>o{x`eTOXOivaLx4>Vy=Ks$CYw<*bGNg&MlF
zs$H(Gq)@WEXRZ>u_#PArsyL>vcq4gxh;d^TzF6}o%&n%ebeB;_`pI2?Y#!ei0%E_B
z07eYMx-x6@j|u~Ku9t5@=KD+Ik`lxC6$Q491<J0(ae(NA^SQ_GGlA~@yu|1;0#&h?
zP`T?8UTT+yFSB`#5&Js_i*HR(PUwgp9P73J`GiU|K$q*dbjn-2yLF&P2q_<bq(;j*
zvq#i8i?b(rL0fe4nbJs(tqNM-ETu`HM(p*Ns;qS2QQ?9?F4L$HUfgYv8+E53ur~Q&
zxkXq8ENzbo8AhmdLc}KALo%EiOm4{*M-RFsjoFKurWv%0GD?z{G->~i{$=%k?N`1W
z-==x&y-8=4O=Q4b<|ptcc~#(FXKqfS%GsUNvtBunBe+Xvu4j#g<jf`nIK1*a#dNhi
z#gl9PI0PnG92+Vb5>A`o&qN!j9QZ|l-{_q91CLt-#0G?6e-VfZm9j+1@KcN+#YvKH
zu9F>PK@M{~`vu<pJrQv<97H%!Nio9WM+xEc2MZSl(<uSLN=waXh3CjVj<5_$D(zHW
zLzdt5LuRl#k+o7YVHz~aMx^Uq5uOCoch~oupCJ0lzohB=I<}dqx`BEy7Bi2%lb-0g
zxQOIzo${NI*#6|nXOaW>pFUS!^n7^DS~P%g{*o)~w@QN%Nru@))`e88ctk{Q2`yDB
zR*C;sq`l9<FU<!zc@KI%`&yifivnVIfOS1tcs-`@kt<PG&8^w?;?5M(-DGy$jlK%H
zmaNZNHUl|~y7C5eDQ;5V_@syk*ql-YIi79@TlFMn!05i849(Hl_bJ-*EP7l$gUZPL
z)dIjqf_pKut8EEl#IToc8hLRNS(50rlD;(hVLc=A=CNYcal3+MM15iQl%5*|_SU_|
zOL=_p9f$sRL-U;o-T54~5h(#4B0TGScf0(quA|L_Z!{dGAl>#MP83XBMVfTm^56c@
zo6}$AO627@mU*N~?-&p-1Sj=IK5Rw2+}1<h<<#Bx^89!vjL8U**Pwr2^%I+E)>q%2
z>#nYS$^N9Z%7bl$yqw0FaLjjH?=Db`Phe>VJBb4NgKf@24}U@5?2dlEiVw1Rz*@ie
zN|(C{^wHartYQJFAdX0jR<-NV99LeJ5xq-BMZVC#Hm2=Q1&635_}gNpw3R8h!ud5P
zLU^LB2xrSDaPuO|u3vdxLW=qP85otKT+Zrb3<%yktmjDIgXXccF0HRSO=RuKU%A>d
z4ZI8=7$oaH<sKw7!P384;vH`vf*bi_q5X|Lw?7elQ@ZHxl$z+GkJZ9_8D+NW%JhdH
zKaIkT3U_27dhhTRAZ$iQ1mds?WU>uGhZtA!)F_p8#)W_S(3)bBLj-F*vc}f(cvaas
z(gNGJsTGW-e6U8r4ethe-Cs;>cr{qAR|N?SMILhysfrPQlCUGt!Lrs5>FM-ROuD;=
z!*f-bBzyk}WXkDk^RkPHbR=n1!)X;2fzx~dQ;cJyYvK-yUAUh4nfh>4g=<x;YfYuw
zBg2oC+cA=E;}0V3)O!}SHv<^-Cb8*SVi*Fh1@hz+ix5^oSR*75`-VO;S)yqMm;v8F
zpvy~^^7tTvZ5MK-xuZsOkAN_w{6o=O7NG-B6Xfs7)3&!&eOHztty}ZK{oP1C$|o*@
z$$4G<S>y|J;3)%e*7WK}G(JWLMVkSzr{-wEp3~fqAO3@qz|TE25)}I4`{vXC;;&oa
z;zdr-BK=>mr7MNa0);(SO1b?H^HM{yk^!78Q+>wu$5_FE<(+iH+nXLV5k3|p2Ri<z
zl|63oG>?MhMb`g=)!1@R!NmuXDdhj>`rrpw+QzN)|MktcsR|7%aaC#mKC2NbC3F%G
zHm&fu!Vd92Ye+aqD_A8HA6LOET0o_KTT2F+K}4&kO|%0M{ZDc=VgU`@)!3iD?=<`e
z%Y&b!0pJ~^UfZzzds8c%y=VP&MJH*5AN|1d{(S!bf%^~5N~8A*eUm2T-;O{rH$YD&
z0u~*y?R-T3Yb0(6Tr;xU&;IofSJzVy7Gma+7|JL7yF|mm0B*~I*joH?yl~uuysy12
z%Tg?slbic!l549GSThi6rE3cn443v|x+;>zgb)7p`3nwIncS@CnVO#8oxly79#++$
z+-Mc`90aJ0qVZo&<vc!*KieHP%sg4@NI5Vu#t=egK(~Z(fPjwnKkR_2emZbG;Fni@
zeD!V(0OR|TRPJ_a0Q{~mRLrxL_HylWS|?N?GyxK}BWN|LIJh<*IMRAp8$g$wn`;^r
z@4kKQw2#M7<RYkvEId%=@qgo<77OtwRbdu2`feD@Dypp9#wpr;jEdE1sCZ*uHY8yf
z#99G^B6U2^OXdTaW6;H4m4f_=iCm$|??#EN-_RA~Hp}sX;&w9o6Hw4s_zn<u4?x)3
znmsn{N)@2iddDQNaWyM32KWMs5Y<Zw<-gV#d@QmkyvO7dUVT*gZ$P1#^)xS(m6NSN
zsqk80mHxBb+~bY_gtDqudC^-6t0oMTa-oazF}jM4Zd3F&f#G#3H>=<NlbQVj$LPvB
z6e|i{4(;J>*bcGjr1=n4S-)Y9Y9&%ch$kG~5<as!2KEKm%yGYC%poudpw4y&3P)&m
zLWM7mc7Vv7aStGEdo<6;7T9hjvcJHZOI7m;?^@*iJCA9H5Ku=Usj{6^b8K5H0}Nxl
z;CTmjYNBOB^*zTaYgC`5hiyIJ8d`9SvQ|Rb(d|u8Oq+OU53qc!qQ_1oDiv5CdeGL1
z&?oc$JJkd31xao@U8qkVC?6snlC4^B#7}gNyH&fNU8i^*3d-|4i;;>kXnzq@C-q`4
zyC=5s47J1SxyxIA-}aJ=`chmMUrL-I@h{bbW47Wm4}mr{fGvU~TJYf8=NXT)1uAwl
zfvLY(1NIztVCb;@uJ?h$G<F&|rPM470Vi-_4nx;Xy8#!{sJg0Fhpy(vo^CZZ605VQ
z0xLy6>zl@tvBGY0VCYegvu5UV1WP2gd|bO$(|$}DRoQrM?z}f7xjq{vcmQK<$PmV+
z!GuFiA2{OyT7d&mYKO)-U@9w*(FQQAW(%L29Cs;tD4A7bs1@brJ_IFoV{>;}x1X`j
zmujB&9TbkEnEq0wDnU&pI?Bq$@7K`<$$?T)0{AVVBVF^%3D>Q9IKg2HNkfsQ-H`Y`
zrYpQa8w^?u)y1z5<%a9GJdd8o3%WY6wk}OuP+z3-K&#~#|3w)W1utq^4_`E4(scN4
z=x0TnMTSclbbDLO>Nvv(ezvp*?@N26?pYdqtfd?+U*9>Mz{>WVR^bR;Pz_>bYc&>J
zS8F3f95x)*?~}2yea%hqG*1>uy(ID;TfP(ZGsH(E{ZGu43%pWHk1;7p>6{_(tLbWa
zP`{<O)Nj`V@7zY^thPq<#ZiYaGUkB_lXb%SWMzMK!*@cn0oR$`Zcs)oKcV!Pby?5%
z%Uo|Kw?t?KizV5)w|k@Va%qdK<p0J!C@B<^MPbT83<}<XfO9d<eL4TLevS)poauxL
z>~x;=HBkX?9ExJgNs=bK^_8YZbNO(1%8$yuWP|+^v>R>y8(imfLZ5Z~gV5e5eS-Q*
zLSayv9JhpSHeOyB9!@(JPWu!@Ur_t1;3BCPdC@car|}gG3{ijPK^NxPG}Bf*z48$S
z{;^b;?pVoYH|F6jw;xwgXcNnMJl3{l?MB4}q5U_#4`Ui?^fgt-X#3hkH|h{9dv(w8
zHQ*1)6;`U5^*9|%wfOOHuRX2IVamGW1Ya!G%IfExLMQQJj+y;o3SW@9u*;(a(8Jpl
z%oyIHcnw3eJJCziu7X8Yj6^naA12h;WN*BF_?!0w|C|1Lm6NKDyZt%Ndn4D4@^Pd^
zyU{xCHbS>zzVtQPyodTI%a-HAqcd#lsbP7W4_$d53tA^1;=Lol=o*HN=pyXh|8H|~
z&_n!L(sRE*jG6V7Uq?D4*@#(H7#iEkXKTzuD=jh?D)a5M=qN0npT66z2(1otx6Ty2
z54OPz(}%}+-qO&{%s&r$B@3{Xsq?bMzudy@1u~{&bduD+D>Q@X^xLn-VDvXflXx#?
z{non7$LJ0I-RC0%p7jFGc6{@n<r3IB0lyt1LP!Hj@+Y<GG6Ib-p{sm0q=f0Wl=OQ7
z#X;_7eMf)&pCp8p++?>bj0vxSQy>15(@6P1ntraD`QSHZ`7dk6;ep<D4fd4(>j(`8
zCb&e9w)o<IGix<Evsz4NFaEnvkan;GGf$GiLbf6|w*-X9sN94`*5f~N*zevlO6&fB
zsDLCu4YFQlH&+kKtLvvBQV$o7fTUb<w$l^4kJKncpv{dcd<#;vFaPXpBQozOUI-sG
z#|zB7+}vxTZ%g|gGiz8>8&dp42RO8cZ#}IOS2CUlu2Ky$SvP^?y_YeXHeG&-ORE13
zG5|JmUQHr6ESRQX9k7mTyP6*Z`<ccJa52WHf&hqe-*VM?x>dK^y$~j>9Yjyeie!D4
zQ!J&dtgO*+Ps3$3bKU6xxFf&QLe&v!@@F5>R$v!#>eb&Xc94ja)LZ-rQ88iqTY{oG
z{npVfL2mvU?evI7n=n!0>@F{VC(ws^2qmgn{UBBuB3K1>cC@N?^|x8O5&7Slb*VT0
zl|PRt;%pUwj*GHb`TyyEQd1K)0zeTN=KR+Ur_)<8pf{Oy7yE^Utcrjii)}EziMF{w
z!-wnltVEp0^0bwOj+$=)^`$x!0hBWFx>pKMGw%T@Z2uSp(yyrZ<Q8$^8rJhwwRVPo
z#02#IUx8y@r7MCJ`F}whzfkO#JM6zTG>e+mEE{0hL7plK9ltq0ty&0Ww)EId4B7yj
zT)p9_jh%S2@s0}YQ-vmh7D8LYvflm}xS~{QZ=BY=|5*KBXaPa3Yw3~z3>O&L^9Oz)
z;8!|q2p;|L*-v0@k+DX6rfqNlMy!&rH~B}?O@VP2QOP^wWN=<Fm*i~mOtgmw_;$3a
z&krW)ikf8q#mbe3-rfW-8F|wDnzdXMa5l0Km#8YEtXR`wRlp$|IuUXN<Ugc!(%$j4
z?fkENmuI^@I7~?|(23Y)Ehjq$t<Djf&oiJAaMK=<)J-tG@BP4tv*@qPeV{5J$-V@3
z*as{xiOY#zw8q>h#!m6;ne^@_dgFn11fbCAw}Z;lO>b-h_=tNfYBy9Gm0`-e;tA_S
z|F$980*)o2OCXCjX?{0Ob?*-IJX^3qCtNgwI>L(Kg{T#=crayDT^J3dXjS29E#p6D
z6W^|vmikhxdyMee#qUI(FTpB&#Hp)+-~0Fbdr)(5VD@NuX}Y%#{{|NT8<c<*9vut3
zy{P0ZH{)vHhP{CsQ;7@I$IjpI37t9i$$flBL-{vhwO41)Hyy`2Du9z$^aU_;KKJ|a
zQ3!*{Lin}Z&OhfiM-^lOqH;;>OS-d^R*B`_v4%E9JYCI*G=(E88}{={x)>9q&=5=e
z$A$MTw=}moT%9k%BR>Xy967|S&!U0cZ=m$$bLd0YpT&|-!K4T6t0Q#9$a&vf5=!;|
z8z-#a11}OlPrH7yUdSG+?P5~B_)&Jv3IN$?ctLfR_P5Ou{Dbpjat%u;p|%(jz%tcK
zwIt@kx)KM@8DQ<&SDkae6-)J;^{*CyMjFiX?eF~TMA2Jn@2>Y7CJ0tAIwY6{u+aLK
z2e>Ng`t8&{T|T4>6HsboxL>etc5Sn1NuV;#K-4zB3g=&-qv5!Vd6lV%@zpm?a!l?x
zk-$GBgu@TbBA^Zycm8q`4sH;K?bQbYNd8`dVp0I&vIc#f{#S(;CX`A!i3CZ)6De!+
zf8T5Z&%&zO`M3|J_#dru2l0B^IN|m`z+?0TO{-?E)Vw_VWBW(<5tLZ45q{2#|3Y7r
z6*La11b8;{#gxFm#6b$m75E1ES#s#_4B}&=%M7|LpjpOXHj+Om=l5Rd1eYY1K7Rgt
z4~XQt@6qh*)16fPzvK{mFI2=67cmpf|KQ&xUy%Xu`ulk1gdl@~g-WV|`C!})v(%{X
zA(~sMp;N$b3%Ht5d<pP=N28eu0<D^7MyosoQ)#0H_*3`K@1;FJ16EhjFfT7@Cxb@;
z08ol3N2(iwq|b(?C2GLt%XbqvyWQ2cD{#BdFJ0YKTLLS!Uw~lB-S|T5g!doyLQg#&
zCdNB|Qd(bsYE1uMG%o%WqQ+nGd0EIU>#V<{!!WUi*-H?|^LC=L1v1S*F#)xz=;`tu
z)H&9QKv24^ziguDs_wp-qv&o*VTm?!p+ntw!2H(Nd1u{rO8|KqTQvu}!G40=yzHfQ
zD*oedX}{g(AoXlK`3Wi=s0@Q!Tc&Z`#tN!=?3j6ZPa<KUYk!ELZaM^=ye5=J*+P-=
z#@A?HW0TOn|6+1S!WXLdM)p2|oEQ{CT#Ddz>&;JJOT?@Qv?1R>Wdx>?h0T4K`gX>6
z*dFMKITf#vf5JlpgGe2eOAO!pIZJUaRHPNECq`XNU3|Mdh;BQ8rGVGsiN({^;@8rN
zs9Z~2Vc)xeLk`NwSNvIISRbxf8)y;EeHCq0Z*6Ifmf#>zK*+EtAfz>oTZh;33bhOM
zXg_9fK4DN$peq{2`fm%T;X+t`ReVXjPn!-)#b(3|+z*JGuPJR0I1TX&SRvzz)gY0&
zDM?5G`}#8Mf%xwn*K`}ID?Q&rm*&rq-i2vNeBXjUs0N3bHgIr0J;*EJUEu0h4X~W_
zGU;W(ibZcbp$$mYJPS2bI08Q3O_$<-AO5N87xw*4A>#X~_u~%an6A158&%#`F8y6l
z0zqds9*lH<`v58ZkP^ng{Vu-yn*z9<YUv1{`R;{_b^DZ$7gp#xWWkA?i42Yp`Ws)+
z9Nn{D7aYOZ|G-kc2TMbv*Oq)^_b3CzOQe{ZFv`64Wd4i@Gm@SI{&9SH=g*j<Igu}c
zY~(G&5&<>xHo~^@<*Tup?g(Wh;K4i_$MRV3Q=8H;;YU45gunNie43iul-at^adsh&
z)yDC!%q=nNb!*gd!jtioawVZClZ~kImlwgZIwXwo<ffR<9~7kk$!q6mAuJZ1xdcvD
zKBFQeDIcJzu=C2N58Z#uOMFwHx`aX>UpbtzRYVt=deBunEyrnP^obN3K*^%eha#px
z(EJTu(8;#?;$*!CP(Y0WklJj3<2$N{y|E4~N(NMV5ZhWUwa)L5{IjHI&8>S2AQ-g*
zkaqbl(Pt9wmU-3lK}SEh5LndjBWnsqRoQ(UKDobTnh37=jL)-SLaVXyvUXIWTy^6B
zU7J`_FwVs_Zsx);#P0(p^V%Qq(E~NUg#0H9eHzMrmA<dX&dg8uv5t^~9y6B9dASe!
zDi#|PyiR_U><-E4FfR8SM9fd@&dJXP%p*%lDQZvB!ECsT>E6E<^C5rrb)Q3As0P0(
zH+eIr<gKFb&=D@-`f<znh(0fYI!cS6d&et%!2&CMhK$Cg47UVdm9<4sx>&|O*_t!{
zSm87*C(AeNKy_&6Nl|;&1+SbG%cixZP1mg{sJ^^7g+G(~25oH(6~QBFslQn{Wh2X4
zVTlGwAe@Z8JFQtSNQ`>HfDF*aj3Z?XWC!KU6l{m|NkKV0fAhnXFP$nDctvrDP6n0Q
z=?ffXlQrC`V1d-W((d^=HN*2k_A_9>FyM?+9qXi(=A*kdkl#FAUZGt6YaftpD*w?!
zr%iKIHV<p#{;h(_JBp3eI->9?z3C3c)GuM9jk(OTA%sA;Pr4x6)kB5b;8S^jx(yq7
zDNpG};inK0reiEpwfdU882ND2Zj)G*(1eeGw(m;Xg5#7kZAcNf$cirZBZ`PUoYK|%
z#+y&8An4V0O+|}X3t1WvXc)ua;?HAQLOZ@coz>mlRU%g;bIF~0Ece}ZK(L3>_2<hE
zvGqR<Q5lg6x%m<-?^Br4BL*1+0wjrFHCrzGOCy!u&BTmFg!6;L0fCRO-K=4%8$>A;
zo4Ww3WJ6b25RBIuaq*uYpMoPFO8o-6y-Lc;tn<^)6V^JNleFMHA1BNx;G(vgCyX@1
zsc+9~`s>wH%kQLIAyy%(3_#v#KM@oC_;z@f;N?4^LC*6eAq5@2q0_}0=n4r)pyx_N
zyE}T1^9(qB4CiQvd*7;!!bY$ksXQX)Y6-p%hur0CSI_dHZPjF^XtC5DJ{E=;(PIom
z;)Hs;gOfb0z@n`98@26#^BskC0QIu<?aqDQMOZ%r;=#Z}p!&hL`{<Bt0};l7@HO;F
zv>w}(-J~7BHfmu4f{vS0qGklwXB0|rN<kIX=lxH6jfG0%?mLGHR?g@Xweozj(FOx@
zH-Og!V91K{JH57wdn;ELJ4y@8d`StIpjIJGbQ}RK0qXa)Bw-~5B@QJn-6YKS=lIlh
z-5HdosYu+gc|@b6=(;JGG&9AMQmotW8rIDrO8XxIyy@^1M1h{;<y0NCvu$E+{X%R%
z4J&E;>pj<fujm^3lK@BiB&%1)7l(~HDTjf}(e<;%j;bxYI>%==6DHaA<*C6<WY_yW
zf^#Fs<_KRS4Ed~*Ihr#U9&<mEveH`1=%Z|-`=L1*W+;;)nx=tP)bd3kxNto9z-o4?
zHu|vKxDOZeOI!8<+?U(vBNJ#gf&%Am3dau!#4tIn&<8~TRmrPcmAA|lZ$=*&i$a4_
z`?Jf7t;+(f4iK+2k0-_(RAx?)mBcZ5zpaF%y3>rou(Fw*n93;ChMj1X0o5t2o^p@3
z@mRiIWe0t5EXeNSeD<;)eef@@?Z<fI#ePff^F@Lnv>_nbQ6;wv7L{NVW-J?ClE!;H
zlv-3$T4f1*x8gbm$6|0Dx`y?3+tju;<xPpQ;-VZ4%qT->>@$2snAn3nhM<fC83Ce9
zmUQ1c5z$r#^$I67`Gw4}0=pjzeBqTf4%U4ZQ_FNk?IC8r*nqS7f;d>=<@Nl?ahej3
zRcHWvsbPm&6E+82G;Z&DVOf_oHj7+Z?oy>E5djetnJ#=<D$FeQil{Vqse{H0eGbv4
zl|XVdCYS1bMba?Y9+~5ZEbgGxKp&Yzrmv!PneWca$vv_<C&TD)I;#H@#qQ}`@0B9%
zXT=ZBhIFrMAJ&wB&`rE9qBew`qXQhmD5{G&DpTeO^f^j(0Rrmz`XATWzcdc)z2~j_
zbkE_No_GS5`n>m*H`nz0bZO|SU^59^at`axOz-!IhAr+WiV<lun%OS(K7ib2J0Xe@
zCVD)s`1n?}M+?M8kBTsE?1QsROjfuEVE#w6U(mz`PsEqF*-*kX**A2WW$bBkVf@i;
zBhJbj-qHlr4zQ=NXhd@fF+A1%AV*6kAIG+s0B68`(-yZ`WGYE;03Y>@>hh>V^bM@G
z&811JJ$De+PBtF9H?;-MTe|8Q>ILYU0Og)o4MIFle@Lea<%JF{k~KHfm2`H7x$B3w
z_3d^<x93X*OHT?;*&>>hScRB*=iU&a?ph+I7}Z-Nm)#$2i&2N#hb7^9Lt#-(2=QAe
zDc}sk;C_=_s+Jr2y*Ii|_Ji4a<$}?&QKQlPrKA0UsO|~Q+piGOQml2L>#{K=S+$4~
zBe>WTH93*Bbt~fR4>8woTQ5FgCiE76K_D^pL=5Up2bCoDo+Jdy{8*|OP29c2ShtN_
z`aoESc>psT>p1^xYpH#2x!AotVsAtJuN2jj7PVuk9|^*sdp|=MlCbYb(!UEFlfID4
z!e$$IjInfqrYO@4Kq1mf;eN<NArusIbCT&nuSYc$R_|Y!^}JFl)sKbZIM|fZ{S{2#
zkAv19VN%Sv1|;4MT4EM9PV;fH`$2PxPf<}jRF~US<;t<t#X|34bVk@jm>s^NCkV|6
z-e*fsip8nRMXfaXTFLapemXtYWYT)(W+JVs*?~>Js`kWUn|nNCA%(rbV<4qW;6p)x
zl_)0-Br6rvdiKVfITm$4ajl#Muv64GcP75n48^*E*_);-V%0BVz@c{E`wZJ#nh<Of
zkLN`u8Z0m|0s_%AC!+AY{N7Wb5uI@3LWl_t0Pn23c){r{HVRc4aBAmXs~oE%=%`=b
z5HW|<E_KrdVpHl%Tj^LlA;Mk0M^}^rDgt*_6XT>h_IDT?mL=|W)Cn%BJA>e)eYziF
z>GoNBi-EEywraN|^%9`olPJK(QdN43jCw>wUlXWe-PaFVp>4opX^pd;3c>n_PN(}Z
zSGJoI#5k<C)#%0$%`RQC+Dh8{xvJ5ZCxw>}HQnc3)_Wa4Bl_k=r{IP4K+YnraJ5ef
zno3}?JoxU?6OOGfIGj>V#Tw4!HdXmuJxSpUPN-T^K|MIkeCeJnGz8X3TwS1|la|w*
zUt8jPg!xVd+P%Ntg#Bn+t;|K1Bj-a?5j3vB2CzD+)2V7due%L*`D1bB+NL|To;wxe
z#dVP{VuKM=FX*+v4p#7TqIJ3nlxp=C)~7tP%_ZNGi;Ag}-xga<_uLa31qTnOCj^hc
zIAwcq{{o<%jX2SBRaPfg_=OC@Bn%S4i{U=ueZLgBT3+aGetx5xN2Nil^#rAEd8tNy
zsp`3}iUJ2QjgoJE0^;6x%f|D-3I#cnE%YYs8Iq*ZYRu_uQC>P<zWYmy#X1T;^XUwj
zMFu+nu{^1=`B<)Wi9=K%QRqW{hRq)2TfhB=x}<4Fq~rXRGJ&=UH!hLx>h?=Hi)wU{
zWZyB<AAvq%`k>+IJ~+!<a>1X0e53Ya^J{c=ii_zvYi{cKPvbVGJ8sa(C;IX>a?s_&
z#!L5ecjoNCUie=vV0O%=o)=>7p4Z7+3d_Le4w_eMUi^BUb9$VN9bOM{-mXZmlX?YQ
zr5#*qGuUG9!tMk?Z)Yj#vdTSb1O$hVfg^9kACUTUv8Ed0mYxK%mLQbZubnJaUsd6;
z(Y<9q*U)cz$8&_YVJY`Yvt(|%-}HWKLi{zT$MAmWx>`-Eb+T>f=|)oi>~P7QaqCq=
zNiprxa(1DJ(G2#!C9>_sW<mc_aB_Uo?@kCqZ|q`#AZ?$%<N8;BQIxgic#Sby!0?0u
z86nI?imgV>i{FrbZVXmerB-LsHuhE!7Hh#T!S(bG<^q%M`KJog{BIvXl05mEF}31L
zOe3B_pm*{5W)Ofm^KE_3eLUm0b<PheXhBX15x!mx{``P$30ee@<ru#O@do#dt!%Ir
zNCbuCyA}`5a4x&O@;@T<q`na&cas5wn6;&AcB-^W>xcfE9J0Ko*4sgGTV~F+5%9<r
z{bSmejJtC@#LXazZW64xdXLqoGiHK#dL_@RvI$lW!>hX^;a2Q)9G9Cv8_I7<(4hL0
zu7%hzo^G0<NvTb%bK~t~6$O(G$-9sz3kqg;v=Q23alEW*wNtjVtIG+1Xo&*}gSDGp
zQdAcMBZfsk&@jla$C%!&J_T%7e-0H6c+<T@tPCgO8CT}v!=@@%V*0pb=n5Ss<c=Qd
zDgvE>o;B=iO@$%!kXidLV@@A1cgbQ0O9S0qPT=WX%pj(w8%wMbF|4z{^jAxM%{bP(
z4b3bwCR{t3ia_Z3s@Fmz`{%b}NNEN&Fj)+dj%p&7f~pJJWd%Kws%j%Hi9Q*Wm|xLu
zizjQGnJc#FBAMsUSpJVZ!Fk16{>8rK>aEz1^m|V@tm`?Yn~FmTY=>!o!oFkKG<&3u
ztCjGkUcn_kOt;r+SU{B$A??32RUu9jsJJfyVJrhl^@Q#e#QPCNFNPqid42kJ#4Ur3
zoj!IpDJ18n6q2Jrx<Cf^0Gv<Y675@lm_#?+Y99j6q{&zLv?SE3p6%W9`l3p>zFhi8
z7k31S<H}xTYECD{OL5?UYK<9?D6+EVRo~*d<J>7Inl_6z;=1C8q%<bspzTOcT5rxh
zhY%<tfXpj)hnW;kS}YEH8e*iyNXmQ0&xpcgN9<eUsad^`A|KPN2nj{#P5PIsa3Zm}
zj_KMHUML@n{G`3}RQI~u<9B{}Y8@!%14!(xOhSXJDoJm6|HqWO$BuC|31je`Ask*O
zZS=CVvI|Cy7pOgF>{rzEUDP-gQgt*RguCu*fF)<$T7G3>{Q~R7x?Kip%yX6O#q`&D
zNCAUob9JNcdFUBTa~i_-<svgSDJ0hG<n=NncFTdsT*`IZdu%%^_Q*$y+8O+{4O~B8
zC@BY~*o|$`LDEkDdsj)f4fME*N3j{MCV?fYc+Z(N_5S?Q95R9!<Bd1>9JlV1kJCa-
zX<8=P=!(J+Tluq%f`QWHpMFglK>L!vp~H65dxoGW#*e|vpEeD46&6u9CjRKVV{j2|
z9G-5-zCSGR#hTXi9v@0iL8tc3#vA;x7`2x;?j0Yhryfl9qAk0-YXS_L+?a@$noJPF
z;x{n^tj53Q66n&g?~4Xy2K-tprKRVm;h@2s;IbBf!xM=Wi9-~G!w?rFnihtZ-(DKh
zGf&eFrmk8=S_K_>ea7&+7U<7a1XXUm6CrLEFqxVuRUn$i3qeeCd2_^b6mxX_l5;Xj
zTJO_}G)1d=5S6WOjHtUZO^7MXEfpHW<|+&yjn)>cQU{-aD(>5_0x2*J2syeq=6>}$
zd6=CWZBy*FB;k1r(Qu?Utwq)`kkfELAywRn2gO$7`ZhsMtoJSND8+l<5>sZ3be98b
zSG-58ZCBjPa9V{*6;`4`TQrO<s(TO8o5D(e7;u$Mh#S6%Hy_wpQYD~odQXIi2huK?
z=F|Z54`7YFyJ<h5-HLqjjM3${cm1BV1xF_YmhINxw2a@IlpkBNMM{#|?-AY;Tlb+U
zji|_I2+~n%GHei07to&;%Y01b1_+^#&W8ujNN|c?#N%uD7JM~I*3Z{3FJa6Gs!T}9
zuo;JvDq%A6GYS%S*^VVbi){#WpQ|t4&imb<^EC$7dIph4YE}hw$OlBqMqfh-H0tYJ
z(U$d<I~W5M_UfAcDe!?O<NAf0v3AeXfNMvEKcd)k`KK4ruWWU@ng-U)5uP5yd>a-E
zKa9euH^LAJ8r_n`yOmF7YzH1v^dRpS*;K(nK(2Yug|p9$(b83ex7om4P?a9nb@Db_
zp;Biz$qi`9d+)uLXUJqgtol@%HC%F~!_~GUM~3Hcl^0EURp`1DRk2}77OYs$+V+iS
ziwo#e#6Tu{|ITY`P))}~?MhFK_|C}<c=h{quLrGVXn9xVtlGH}yUZ~Pp^Q+`d^cSq
zIegaw^MMvNROJL;w1<hBg~8vRc|#xVD`k{n8<*$DC=k|>tt_C;x-cmWeFL5z=(T04
zCeu`7n4cw`7<OIb{#Hoar-x=YMu<SC1e^JYh&J5g?M?G_Y?n^pe04Lkf{s9Qi_3xR
z3C56?DXy?2Il5)pNLP0-f_?BfH7VH$lkah=ToE)nI``Q1jdpX&5(0IARs*BFJh~=W
z*?Wu3teMslt4Ivy*1k$`%Bux7B{2S~-dKUyX|pIJg;%QFB%T>B9j&OM&_*0=xmy^U
zV(u~5c4AnLh}4nR#YOxUAuD@}ERM+vpo=5Y!iU--BG(P;uX2jNj>kVq4mH6@|LNOg
zN6_icB+~TGnN8e1UMS=TZIhcPb7ULN6^bTVpxYM>zh~%~`89$OzwIoZ&=$zgk!}hz
zeS!inC*qYxTlN3iIumH9{y*+Bp|O-1I}t<nk$smeLs_#MYeSYS*-F_nsD?pAND^9P
zNr<f3m$D_xNGW?^N+HSG^Sz4y?>x_Q&YVu>+?l(~_kNep`}Ka`YQ){|zDRrf_zgA5
zuY`0ddvFP_7pZSH$YE|9cfbP2pEzsrZphPzpA~<N19FrF(|M|No#o<R8`@rmMhdI3
z7;CmSXIvA0es%<$)nulH9lU}l=C<7P&X&Se5scs+%(xoGQI}!iT6A{fTpls*3?}Gx
zzGYCX>NNfkMPvy*+V={lS{?GCr9LM`{A*`%%IC6VhD&faH?$?v@@Y&tn4ckF_mEPD
zL!gh@4C(~gjL&`-+u#uMPdm9b$T?ULH*ATo1afV9_}a%R0Qjpr&<?x@|L+EM`rA@^
zG>|?!3PjE>h!;}$cxiA~9RiF|YJ$T1C*IYQ*IlCzDTn|)@l%Yl?~744*93Wz2n0Ae
zm4TT#BmzULTTxJ!U&_dpXCyysjIg=#F_1j*9@PGeAlT>x<8lM2)8B?TqMqy%b;b3|
zU66KA*bPJk@l+ruL})nyaabHIgS~;s;M!$oAYlpB)@8h`ta<BpCEUlvrk`UY$I^Z*
zU!Q^q?=Xhjp>J)iN_3g+rn<Q#4P@%2Tn=HW-VKqgtwTc&Of?_mwXfx57^7K;VI?<5
z<Z%<I^PC{eONUCj45Efwt`TeikKko0oBdPX(u-Q{)zR~epl>#eKb3@#TKq7R+=L|X
z1RskC;UOq7R5-zI_6w-Qo`L!K^ZQq<V9?SALrhhe653Xfj$s~xeE99?;_RruZ*azG
z&QzWQEk~Hc{LI*2Ow%ryh8J3YGYMC`fC+t@#suzWp)--2Ne5$pmv<1?n&>fX!^}8!
zRP)Ac)wJ57sj^!(Yph6xb(QmGbA?TwOud(tXfvddrfow&hji#k?Mcdb-23GE^Py-<
zF_N^E3`vHBA<0_F@xMUI-Sdg%%S#s#jwdYZ+K(m*BbJ^{-3}7ar|zsXvZ*C9mp*k)
zrO1AQ5Olnqe?;pN`fXg53ZKPrY^~|3d!#R?mnsfjz}UTYOT#+Hf=XUhk-+>ak}|xq
zAxnqoN+g?}^tqQFcovgUdG^IdNSgGQHWUflV^}P4Aelz`RO<SWF)!<L$#N$AF#B--
z{X0MSLMTqyvpWVkLA5O6jb3kIM)RvAn}A_uyp?oUoUXSahERLG9~B}bj){Hp7PizL
zcRGpbVlgp>M_T!<hDCV*R5P>H#}%9^QUVNan&}e3bfntdtKR2(6+Lb(_3WCZ&#b$L
zn*(cUvq-M0ffziP<o4|@T+tuk2c=2!u!L96>*X{()i{`O>H3AQe%bJIoC0k@O7>n`
zNr}?BKZZh%(ry_?|1Kea0gLfBmCxVR2P#I<e9xVDQ$<(?!4YUTX*Sc4)3u>h4*^Lj
z1qX#PF`5$x&<5<%o=vVu@e^BbC>FBOUcDz`achF-ZGONh@~m(lj~Hcr{>`<@HCix%
zQ;ys)QEa=TGUzyz`|E*vrSPhq<uHs`uyo_cf*fJI_4CN>hXSRwQT|fQ(syx-tCOli
zle?x73rD1aIA@QU;0U<Ip$VihAEyWqjGiEWq%d2Ig+U%1h=ZWJui97}Xdw&NiR1bw
zU!H(!3+DBMca<6yHQTiUo2l7TA^#4W#n#N$<lx=9u@j*4VSs_P2TE!JbZRv9u)AOF
zl+HV$*0KZ5KP?Lsa?!Jv4Y&0w?8%ThRbaD_?kaM@#g+92+N$jDXKdmZzo|E~4@#I+
znS9i0E*TF?Vls66r+MPIAeWWER+-NQN|oFh0YCe&7#8;X6PxCV%I?xC<YBDGto^Q@
z1nKxgOdLiyqYKB~<~|lj^CyKV#>~d5J`2A426m}L-AarkwuF7=CQ`_v`tNXP;=uTP
zvyjNK?3Nv9iZ<FghJQA-Axk|L?4ISXyClThoqEy+_brurzJxR8d+1NN-K|{_z8&#u
z9>Ku?hK%Va!Ywz*iSVfg0RlmIig21gjUY4?D}GbHt5(EH<f>a!x=;A1!ts~>8fS+7
zX+<0wFb7twy<<b!P%mHalHclRIDNfM5}Y&YG*<)0m;<TA7R!8^igArQxlO0D%jE)d
z8HU6EEmChRP`yR;-IX5Y<0qzGR}M^eTzs}Pqv)><tY|Y4e}CPV!u^)`RghcsB5Yz6
z5DG_s#+Sq}_8E{>$JdP~tpq%`PN>~KiW8i2J14lT3~RYDeEP>12kwi;+)<~)M)b99
zp<UZwZevMqqigSSdC6SXR(UE0>5AbZTYfJRfX3^;FAf^$BqG($-K*=S|2+2TcIjY!
z1vVRd56-jM@TE<^O{HDG-B!MG>XhhzcnDzLb703l7#DK~{ny`Dh%O)P+W*gl2IOjO
ziN_4!y#BfOv~u<)Mtfp9_{pIe-HP(e_?~FK+s5UABF?3~v+I`u$6MR#SF~3PfMn@G
z(-L5W%gGMim%SOFPvn+-VmS^S)jvmKd^)IM1;q+R?6ofqI2yPZNX`_qm;Q@J*?=bP
zW)+@a@%JYH|C(#yz;-N2uO#+QQ!B>+Y*tGp^BPjwHQ+rOFwp>bJTN4Bu}CR%{|^{o
z1~;9&X+RA)lKlWd20`fXib*VDd-oAe1-dVUw|&M`|C%SE@BGOFHft!l<s!1zzV9~~
zN@`M(41Fm@ukN442>56qj|bB({`c>?MMK_+BrnO}eOheJ09@H{8;REzd#*)ju67)n
zCh4fJ?Xf5b4qMncaBLD6>Gm0MfUW)QIQ0I~2RUS_TR1oa1vog$Cl6ir5nNm;Sg;(j
z3Ky*U4{MMEm5D+alwR+11wCqDpUed-_RRk-l5A2FptJQYEgy}hZ7GW3Z60L5j{Vmx
z;dnfMzn)uBp)Fq${L#SV)m`+!{azr%6_CGmi9fR^K0PdX7K#)IX)OHgOXk)7eFpev
ztvusc{(Zjy5)>p6x*&pX5tfTlN?^J2@Z8jH@E?Gvc;mK{r{V*9<i(3iwIF1hc)`;0
zoDT2YMI`osL-^}3aG9^r9;-xfM8Jxz^6y84K*?O5x!OMwYP&f1SNbVHLeYyhLU0)b
zVv`!vAtD0ca3h;jw3hNGeJp#&^{vkvU4-T~gVliL@yz{_r4%LivC}H#S9krNuT|HB
zZ_rHru{n_3?IN?^BnBY;<r)&HJ%mt$f|f=BV!lf^+~`&KQ0!gWOygQPY$e{Os_5RA
zCFAbs$1|z@0}XUcR}fMt;Z<Cw`*QU|Ale)vBPNZ<&Ob<q`>8PMlCp6$(c$X$>MXc;
z=%Qy0AvWL-V)ax_V-P?zEN#4=R>qxM6y}W}Hh#|ZA}#jnMQ22TAMr88vSF=G7Z+?>
z1J^B4g;xDmVcrQ~<;x;xLf;SWCUupA17qQ-?~52TQha)l^*}s6((cjx+#$5RgxgOV
zwgY&4K5y53wU{O>bZR5UARXfy#Dl7@+<B9F=IX}a>_jx<@q;{<Ox8ilBbJ`;+cwav
z#h_$F^2OauLJ$dPO62AzLkVY~&TY<yEr(>bT?8Mk`sTgsABau@B2j2J>IS!2+smH=
z2HlXp0={B=*kfnw%gJZ$BnTJ`08n&#_^;9YFtXja7yzoT22bD*dU~-ZUs--FoDL;K
zii2Q0lVI>yr<mh-7IEK^{FoStcP@C8CWc|EI`|f&hBS5SrQwwQ?)KPM=u8;WsqGz<
zNMxIJ0%Tg9<y&|G>i)LH$k4l69>0up?%)kZax^n^QjM&ierbRMK7sfM$gWio2q<}q
z+aI&ubWq)d2)yWVe+ax$oi&gkR;k1vP~p)0e7XizNcDz!gm=khIRGNp0nk$X6`)b8
zvP<RZFN@VSN8cPz1fh<SB_C5Ey)gJ|S*PdHY85!0_7#CMY(t^OeM-~uP);LGhWvuX
zRbQKmlseVd3pzG8I?4m_nm3X>?YXJAst)?=1|i)NM4p2w))$*zxC}5bo$JpO{c6@%
zAOI)`iBjzO$~qvI7F}j!QUHYgsTvUT=VkgF<gP*4pCpn)3f;G|!q4;oB=;m@JvPs5
zZUZUH=6K`Q^7|ISUXa^a4RH^Z8O{l{!01c%qJ43tVdY-syV@_=p<NJxXAIid`+GnR
zyTXRQw!X9Z{U&u$!o`Tc-F&=eq+nzc|0{x+m26Z`&Z(d>sthn?#$>J(6_@K@2s|P%
zx_D1tU)vzE`{wLCh?$e5Vk|os&PHT1ZO<$E(HC2k@LmNJyd{D_Thy`eSijjGCjz1Y
z8!Xg;<scQhYcxXxUvA3Tu{q~`1CCxv%qJj{_q-2$W%QeT_D}6sKnSdc9}WA_9P%OH
zZo|g}>LTAFAx@w<!SUB<OXE1lsyS_{6#!E7ULNu@v+>7s2y|h4ux}W!^!Z6=QKcf3
zTAikL%@NFma4UgET8S2ja<jt)%1HYqyzq$P13d@31KRRgP`kLNH6L*Zitu_p#3nm(
z+Th3qOxjbghm*gL*L^jM__I0AZY4Fs9E3T0?-j)sGhUwJb}ITXHJ*i^DnvJ@u+Z60
zmLs4WyW(1=Uc^ohLv>KQoUn<pepBd#V-oVQ)lTv6{Hkadb)zzM0wVS3*zZ$+XFnU}
z|FZwyJ14!sL@fV~gk$=3KTvNTD$(HY3DIGb@wiJBlw!g?Vqxie1@Ed~i^-C=hN}4f
zS5pqcx>o~dD1QsXyePy(ZFWbdSf*0H`{K#;9aCGECugfQ`zVy(hR)PBqcn2-p4-st
z{E*vhW4SU0(R<u0cHDv=0Qj<Ns@Raw@`aTP>2-1yf)!qkANeK7-w=V~V9E04eKl!_
z6`D!>!K2vv@bh>zde-J=y)Rdv`bq$0cq(eMrctdX`$;*846<3ppeR$~^zv+$+953t
zZa}QdrF23A4S-q`emIYomw0V{t9te^9!Q}DjhZudx(CcsT`p!(5m>#lKm%wDX|DNh
zv95NY8%e266`Ydv`$ct@$e*z<>eh7|pH{NhhVGmEFryJqxxCyi8Bw+c7=EwqU>g3e
zFGt}O=?y<0t$v99#0C&f0kWcZtn`{PAT_<-{#vkZto6B~K0Og+X}PMkru*Xq6PB&P
z;9{1}J<=Q)p5sm`?vCO+sHWam3FpH{pkTn_Z{@2?rx#C=y*EJUZc2(~7cHeu@mSbO
z@2VZ%J`g0ZYNOK7TJFsO@znF6p%#sQTG<5BP{}w=JrIxSM($U)rB^Y8%MC3F0eDYh
z6&5(M?pz1_N`1h0T&h2so;dwt?CQXb@yutpz}3oi$We0H=o2UrRN4h3VNc->nOzWk
z22GIwI0^2cvu_n&*&LXb(B*Zh^vw;Y8ey^0W%t!_DWe%JccblX_)xLqllc5N@@%o)
zFS}=JA8Le@zGPhT=BZk(lYc2B@!_-5$P~EKt?LA!IMJ4tcKNyL`a@=b=X&^F-%%SU
zLi^Ap8q;)2(B?ThLZ}*@SM{BP+{$-bF!<X^nElB6+l(nYgD1DmxAQNB-6SfJ8^;pw
zJ%AUNt<QLaA^Zqsv`9Dgm0PRqY(*h;uktCe@>tb+!6A>*Utgl=vuzSjHmGXal8}|I
zswYD+O_5JN*;E#HFV(=0>qZed$Zs#Cd`)7)6-<@SIL@fd7`rrcwM_w6wDZ%-S>==3
zIp(moWJbD;>_es%0C8j?^Pn%eUE?!E2d(N?Rw_1p@>bBJlE3=l4c|fr-h!L{p~Lhb
z#Xza!smyycz9^oE-}8^|YAUO^-U|9Cs1Xzzcz<Hb*k#g;m#W(LNZ^`}-i3E?xe_h5
zA|VD(PJvRI%FnmHBQj3qAPtL8qiN8z=u<I?lzm=(7$#E;-{{6SCDV$fjw9?#FC}Jd
z>9gE{UcbeoP7-yFuk5<3w&IiiM;r1(S67I`vP{<E8pb`$r*)MH>^*a8r*OS<3uh(|
z;wcpADcj$-sklV)-?F7<7H87b!Ip6&4XD@+Sd%e?Ls~W|os&Xf7+AW@L9`NhQDJ!@
ztlA)Zpcexscd}(9^Un>(nks=4?6liv!-;8wu`x6ii&x635sgS*fh2vhVPJYwQvPF!
zyDaCY?fdM9g{Up%|8#%ScHCm|eFf&Thk~i|gSK@d?PACY#D`_NHV<03TqB*XO_e`)
z6udg{uyNsd&AbF9Gee2zqF0G`3d0-C;%6^svxh<<Wblf2%JNU<3=%iOEWz$go<DtS
zjSiaO3%>_o{+<|m>0Vqx%*n!p_;+jQNQX9dB+1>z=&}~h0v!E=JTUv5iwCsBweCdA
zxVq>_&xXj4)vIW(Ds2687G}u%cblRLwT2RxBua|=wpoeieq9s5mr+}t{HzpAhxZU_
za&`JfI6VGd#7dOdXY&aC&b0=V#87uWdv<-hkxD^)78uu-h8w4HKTW*rd<f!wDNE{I
z!ad<w`q?`5F;=%X_H3VKrptd^KHKn3R(>_9E=EI~a<dp)Y$K%9mZrz(Wo_vi6@8}V
zCsgTm+^GrWWs=f<ak(q%B1zPDWnHFH9@V$%l$P=ck+DQYkVrX7t~87?B-G!&OWPms
z%QZ*?RtN9<zjSPCHN6*^dL1IlCf3~0H|qQ$;<fvgmE<8UTo7%L&xyg_W3Ndo+-36h
zfuC*)f(cNktzLGBepARHuSY$8FGq#nxmU(rE6kru34&ayg@trL!zl9}-SDDD+L=4D
z$}V09Q~ly)dj%z^L_*T{Us=z|UFG`pOSaYZC0Ew1WBH&1NkM5?AnkSxS=Jig<YUj?
zi5+%%^7;K+u$V~D73w^g34V#y@xkc@fx`N4`2xN7XE^3OjXrCG)nlP&1h3PSt4(BV
z`prKZ5A{cUWKPh|mV`sGFlWU0M>EtYr(Rb*sivrg^%&P|hgmr-7YIYnR3{<aeB{kP
z3yNE@V!m{C`Uo;fY9z$Bn+-o~*P!>ZlPc_D*A>6|`A)N0I}3XXwwhnRNqP}j+K2YC
z*%a1!z8`J$`#nDf^we-NicqKkXYercF=l}s7Q+n4-ZHaw&)V-3zpX4AXQbDm;pI3i
zA&_X<{a(W0Ft#p?%eh)VbKnvLjVpQx0cY>g>fgopooh#G{3!#dRX(lW6>Q!em7+B)
zd#`$Qgh=oz4h!4JeLrHa9>7IE!tulHT>+j2%T?Mud<3^O{USnDy>-F&Jh4dq=~XFn
zmx6MHJn_tp7q#Z42oR7`yr8~0A-=30;JKY9LD}(WZmWsSXHG`FlA22dGI31Om4EKI
zLX>kpP>Q2?k)zD-<$1(J@w;2HifOx<j)l#ii50q!^`{1Q8C*wZ-0LYVZ~M4383ax!
zmh(Y~QRCGCUJ-n|t&TmESiya<N7@xcbc%x-sx^qY{A85~><qin%r3ngSPic3v~lBi
zbWb}6-zDG41|3M*>5p86(9Rw)XJ&KHmVgFv4*9Ak7TN#CAC;;0!nV3tSpKLHdf0yW
z`>y#yOPxW_K73A_SFDY+IW7u2!MIlo__MPN2%@@rX!LLBxPZ!Q9yM%M;dy?Ln7d6%
z>J?#_*qTM-5@jc?EO(^lEEFuP3O;XIxLwA`cF$ORMy>6h;XHpowmROtqXhT>8#tc*
zyw>rMP%>Y5XYtdO9I7<@`sVnb2w-Dy@HB1zzTI?yk)^?Bu>~>`!t=8N^r0cW8^q+8
zsDp^SbSTya%MuPI73mKWRSN6ZUV;>Q?ts(l&5RKykckiSkX}yrG_xasMy_*1Yb;>f
ze?H(#xy*4E|GBFVBcb6H%o4L%TjJ#J_w(0cYhQc{Av?=-DK!NlCM!kiBGhF}V8r1C
zD0?~>ARo4HP~)Uaezat|V^~TPaOh_=?-p(y%rI=_`ghTajqLltK&tcL#MY12Zm@c@
z0x8Qod6!KsEz#JIJ`d4}Dhzr0?wS;KXIV{$FAV4b`xlObc22v7%}AFMS<Sxss6)y?
z46-?qY~1gKFhE9414~zKa@FO({;n3CC(UJQP(<`BgmVS&qBT3q>FJP-DTCHzi%Y0G
zmF9JTD^9p20!j~s(B#C<+20^yzCCLAk(C}rRfI9VU$Bty;rK`X-SP@>6lw(7m^F)^
zyF(O|-067(xn8_!rJ)-C0LM9}jfr^=8DM%M2oebVQL)a#8Hwr}bIXJGcPcJZZp<Ai
zdJU!SK#vm$L2VV}XWJ4$MWAc3?z>~y?KME!nXSJ%rEXSt_|d6UJyj4Tp*Gh;`ZVzq
zcg}0Ptgy@5Gfa*dlo)Z5v_Ex73B--Ff3*ci?yIxTAQ!x_^Q3_swlRzSO@_x;mzX)C
z7K5n}unC>m`8~aA7d5m2`NuXc9)c{gHDGnr1ubF^t_Ez(=cfa+TEo|xFWFG=za&`5
z+Ff|c-(UPDq+Q(6v>MLy2V~Qm4m>d-s|7{cJ+*K%h*13$EEdbTTiK8rrV8RLc6Hl!
z1_>5Z9zU8b$mfoTb0BrIlzkmIP#s*KZJp6<WqqDLI4U-Lo5b(hk(VXdwusMn+}YUB
z4fBxI=Y?79O20NEs};+_nEMf68k1FmLYY*Kn(A;UIa*qVjZDNdVb_W;uH^Vvm0L`D
zrCC@Gi&)S4!Q)dj@<2_;P!)9haj#`ifQqx~u-QJ@tP_Mhm!Q)VBGnSV*5dDVA>rv%
z`7KUyxSR*#lF;-(MbC{_)0#33rFop@V<Re_K1Mz!!6-V3Md5|`j~x#^4h}ofKprb?
z$a}oqF|qk+ts!7QPxv-4K-YoQ?9o~IXTe4ig%&Nc*-P=ZQZIp%u4J757#uE1DuL|S
zLD9g`%ZP@`1$17d2RGF-<*^b8*FKyPSThO2)~ok;&gC{$33@_VWm-5KEeCtNcv{jA
zV5K`ET(1!bAYs<#nUA&O(9#x|1$f$*Ssa<k;Sfz40O}fn5?J%E32Q*lYOn`-)+~tF
z6@`4PkVmVF)!N?l8BYV4V0S%AcYL3M3#$k6T^ICt1oU%d$g~E2Yr8&>svhub)IA+4
z=w|`Im!7&ai+v<8-9A7sxf3!$_0<K4up0+`1SaFk5!zE~3G=_9nKv~VvfF*`%g8&*
zVK_wGkhUrk4^$9IfPUbdNUwLr=DW-m<bQsj83>gz-h_RYy{7b|zn<*yUF`nWj4=5O
z=(yEiPgGYizC7_tCkQ;SfX%rly0u+ooANMopUPVoHmB=Ty)3d!&sk&-%f<qe9X+^E
z*E1s{1|!{n$ikU~X*!Z)Xic5{<X>@lchb?gXthrCkTqO5N@E$K74dHgcq^1tCj2}*
zb+4}@VgvyP%Xdc)3@lkw1itvCVNsG7b5jkexh(SRBVESCx%gI3G*XLjN%e{9x#AG-
z7^9*mrsLWlb3#q3@l06EE!`ZaQ0D#v6PnCwm$(``7Ms0~(k;nZG2Xb*;@zZuj;#6i
z^rH_4UWDH{rr9pn9o9W7{CiG}o;Ah$teeUm(4%vtM5_1ne2P@ceCH$~b)L+4Xo}`i
zc)^a@c)`tM$9~?~Fy9s{(`-ZV6?0PQ37Bw^uU$+~@=u7c;r;Nld0=>?_U7jNgHF0-
zo%64RojL}b_|*UcPHlB~nnJo?j4JgcKd#43#z@$G@xnoUoc!>Nrp(1<KUx)*Mjqd&
zb1Fxki!(Z0v{&o&<{6ZhpFcdEmg9-G7<)v;3T8^mit(<-ceHZO!skMN%5QLovzqpM
zPI|DOz)(**@t;mY2qjFQu<&%N=GJAc8H8Gb{B<~&(bo(MCbO7CC>@1KCdOL8r5fN)
zb~^D}<TI;xwp$dyj3Yu=DhXCJo@;EqgQlo3NeX>)7sbZQWRY;KE2??E%Wm-qY+E<-
zH;T)!qgn?}*Amr)lSV0FO?1nDA;i&g4`_MwPVq&;QC3IO_+YUn0r$v{1_?(=JftIQ
z7tgMxGp?7ZUy~B(hs#IZ@H4+2F`c;uRluQ8qWi5)+hj`{-(YOK53;sO2`=XAr}X(L
zLzLG9T^hrUCN&tkyI3%WN>dYy;E18IHm#ezq2zQ2Wkq0{x<){`5xAzVzd~Jx^WuMd
zRQ>i#@J}w|24<&Y2`=CKudXNYuHQPjo_e;$-4VGA3gAr)V4uUChnn)j$$8bk2|~{r
z0#?>>S=P?mZcmppi>z%nt3?JgD#vQssR;L%Y_Aen^R5M<oC%y>m+QmZp6Yy+^9tii
zXE()gBlX&tc1w9}EC8aatgYpb2r-@3lLcKwJt%&57!)5|iWRu8TiQQ%MH`!2{j2`%
zmtOVb>RNH_Vm=K=Et(L5uU*@sT5h%EwUoECv<$RNX@&Wn@YnR$@z+C&#LzVl5O}rR
z<d#}DwBblh3=)6rcr!*xFFJ|;iS5&qi}RlnJ`hzC?Gi&1?<V2|#;!k6F-rxrKu$wk
z8O)33`MmzyaFztso85_#%dxak9-tt6ytngx^;#HLb3RiTp;x64t?`|1r{VNNho1<R
z7;3yz_@QRaAOs&9_wx>Hq+u39w2khqRy{%;t&CPdtD@D$9LF4DZbIyyWcKe8FZ9WQ
zl#-txJGaM1wA_P}g`*5XS38w2nQ1BmG8d(A;3^22I$;p(M>S`<E5?F8^$Vm`FK>-f
z@-EEuJ)g^pT$Z;xe)4SLs_T2bG4=Gs6pGwdtrjyaxeD7L+xElajAfdaD(r#*i|i`b
z+?v-~-rA!51O6?~9Zh63U?MVg-wI`RXtOT*;gsxr=hoFUF*b46Bf^OoM!cqQ($)=)
zv&<P~u<i{Z*p1M{)61qtRzf~X&ar~Ac76A!ocyO=OqY1sUm<CZUg@bxQ2bQAGk8M%
zYSYKg+t!xRfAU>2+dF9dql1g2oF=8-J-=KUf}l)LLNUOpNJwWVf4tx|ooh`Kg`OCO
zB6>3Y8nYsce~V13*5Gj$!ksc$uJ-ThM8qxQbCb#H^vKDf+J;lvGe*kr<Fi}_KPI%B
zkOAS_Gr||4*%~C4^sm8)h-C$CFQhc48b0QeAjN+kn+!ij-w=Duir@JLb}CaK1ACJo
zlqR&9NSx*xc`l|m@^b7s0Hkl8J|Y)O>xE?~M>C)~6A)5-%rKfcT?UTQIvzMfRE~p-
zA1#vcTr4p*+l%c;-9ghqF~gaB|C6GjMM}*#l$zr-Z0z}(;4)!0H@T3}%9Ncg4-Z!t
zb9EcV^c>r~{x5E)UltZFSz4|B{;4nx_JD*UEqz?`2wzW}vxW~^l*S`kz9<@hm$gNs
zp}IMuVx{B)CQ|Ovx1+@hi{zbU)XA4{s_Qc1sx)YQ42`<dYVqx3lhA5q_vH_9qVgpJ
zh8JeWB=&?1J}O-(*oZ%kd$$e<w$v0%3R^n>mc0>AuFdSHQsSOK`jKVeV<~VI_cX$N
znsr}40>vEgNd><3(Z8nGUE$G90las|;g9IvgS&dTVdmHYkdqX1&u(8{?13a+*$3I?
zUC`nFd)QV#3Vigirl9S<pa#DLvKxxb%>W|2cNm~LP6amOH0>32+1n0qJsfg)`P<$B
z&-O0>A_D<7qjl=m`P&#!{rY^H|F5MN%$qWSqWBOg1YNj2ty9Vn++)`Z6wK51zpsH0
zbZ~&1NHF}HG`f40fi{dEmXuEp1HCTvYLa5g$aMv*)c<Yi{R{v7=Uk;C!5#qLbZd5h
z4?6(P8XjLw84KKxU4r99A!4h&>0;gfW|PAGu}xeNbfWvAuOM7287yJhorDVhZdGtB
zDfF7gA5fB57_Zg)j~g5S`J_lI`*NQDT+R@X+g_w-4<N<8lVE`MS<v;S{oj?_UHX8F
zsdHy$FW;3x0Y4M*9#Tp}S&tpq->wyU(Aqmsxmh3(?>|8;1<LCZ4XaW5Uo&I_GG?Vn
z3itfpQ`W#Y03#|DiJ@eR1)vXqTM`$(K+KnlWRctl>Ii#pLa7>@=EI`rp~L+bwJ{e1
zPG2~cN%((z=zwrx?ouZCJ<S<x&2SQYcJkSDs?^?gxHwvdoTf}?tr~~Dvj<^^pdLU{
z!V8A{dn^7l-$Cshka}xHAOCe<*oHD^f!Z7G3?*d!Jy+T6CME;)ZeT|FkeR`4*EE~Q
z=(?}vP_BmfuBz$Z&e{z^Cx%i=m%GH%N1wZ=L&y~rcHz1@Y%K{Xg*F#^<-5UCnjD~2
zUHM`yISq>PkZb`}@3Yx5Yoe~x;}^z2NGJfnE>&*p-~w6QnRbN^L<Smf^W05>Uj}*z
z5H;)^#8S0u2v89sA<m19@*Z8}>d4u~U1AJ81x<{GWTY_q&>JGgR(cgBcR4eVy3_>~
zwSj7up9($EX4ke2*|dYf!=@a8f$2s$$go*G<_#(ft0%_Dkas)WH#mts_*Ru;jKqs~
zdB^`ezRR?+hNGaMIS4&d(8pHcPN#EUma;2&x>U(Jq?S@kddC(=z@d<(^*;?8e*)!2
zF3wL~MPeOdl)vc-?zSf>W7t#Dtq!vm{Q;~TA;Zexdh@V`SN{ceVbCw0l-6L8Yl#s-
zajUQjQpJ1O>U2Pm7xCykvu2x#0M$%1mLE3rETyzhjmTiCn^i^<`2u8W`lZKP#X7~h
z89<<ns{n%Jh?QVHyvg6$_$TLS&|YY)LgD~0(BDW^O|bo_jaH=Dy4<YIji7Bi?4*e+
zRYLHz9V}~|dQ0FTA)>DJqi|ehgJLcO{-s!s5rb191A@*3u{8l)b;A4hShX&%Iw_QX
zYSGmKVfU9pQp|%ln=)f7vt>Z{8Go0eh&s3FR&(Cl*dM6VaORSOCG2VJyYntvoihSK
za6YY9%4~dTM@A~>k4D9n@?VBaL=hhql(ivLpIUK{gW-x=r))Y7@v(zu9Zv-9wc1ZG
z0JPUeCO&T4c1C|q7r#yDXpvg+r7eh)Xj!xzTAqr5$f&9P4tue+b`Trty?uEsc!^Co
z%=W1o8>8Z4en-ooSV+g`%;(@{jD~LHeoyrJAw1==Cg%a{)nX5nRP`<R;g(h|jzyuU
znBPu!oN_sz&E{KfAq+6gOBf8&d>~b!=w|3{8CN$R>54W-TeM}Wb#GGepGgBtm&YLV
zjwENT;d4@+Dj@wWEdudx`q{>~J3oqnYiea6pc$H0H9{(eL9?~6wN`ts^jGPIUpQ1v
zAK_r<Br~RSj&P#dZ+8^V94$61Hi}`V)Fr%TcGAshUzQCC{|xb{`=$;p91>>lNa{f_
zW7^NR+(4jCV<X@!TGwzWdpL*I^&FIUF&Py=;K|E(*aGpMx4a<6h`|4N7Z%LMurKMv
zAkUTUpv|r+L;6ZI?In>?H>q6EN9|y6$C|Y*5bPKl1A3yt^n!CN_$5=U-fCAMBn523
z(0)Q8RGYod?o;RGCR;PxK+<=yAy{%P%ify3@hGl6Zg$~}PWRtz=$vja7}PSzy*A3C
zpgcDrOkw*}0mHC{DARaVnpv8SV4|WX(xIMLYs?`8ilvKXp0Z_Im9=(hze6Y`+;*31
zo>p;=J%8(HH&S}m5q$rgDNUYX4fav>Y^u$ubcRy1Jts^yNdq+PaQz%IjJ*6oUwLz5
zk;-FLv?{UOwN&nWzzT<kolbP+F&b=3?uX`y3kdh-^Q;16D)-`$QyMr<ls<uGD%Uat
z!A3>1#!RMLGZQejbueku6UOKG^RTB~;wnlA^|SH6f|Oa-IQE(uC2%vQX9^~Loznk0
zy*lQ|&O#nibwTf5K_fO;#d9I{FA&nNn^Oeq_P+Z4X13LftEa9+RXDC>j{KZ?gS;d&
zaYn&dfCH=jUgv=60Q}%o?p^#36b5Ty+YZkiD&X*Fqtnz)EoJjpt)yetN|ZveeQ2k3
z;`AT*Rk8Zz&CFk#C+8qltyn4c0AyRc?L*`7D`!k^AL;;^L(uMv+-tsmiAky2A6^mX
zfmdLd=GaN7C;?tL4){ZcK`4$YWc|zH{z#_{^%rn)c^$B@-5=?8pZDW`x#mAR*_&{E
z{qIP38{7wmPuElTXgN0_yr^g(kpFRgM*kb>n80Xt$Kr#i7c>t28|ko6{9`-6e$4-l
zmjlXKUs}@t`oH5qNzFj>m-;C4`u*(+grzcIUJJ^ziTme(>X!x|O*9pB-W%zR_}sN~
zpgB#_t9`H#P+K5DeJ^rx4_V?k3?^{@%bb9wKfECFVc|j7oUYZshqFQxqMyva|4>p;
n{P|Nlb#@*+ZI%Wa5)M#ENZs*2)gL<p-l5RbF~*c=;iCQzpcr?m

literal 0
HcmV?d00001

diff --git a/all_static/images/whats-new-in-v4/sankey_direction_reversed.png b/all_static/images/whats-new-in-v4/sankey_direction_reversed.png
new file mode 100644
index 0000000000000000000000000000000000000000..f57baa996f1bef66895c96951ccf76f1e617735b
GIT binary patch
literal 29783
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
AZ2$lO

literal 0
HcmV?d00001


From 2c4a59175e9efc5172cc0f8296d562a4c57ea23b Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 29 Jul 2026 14:09:26 -0600
Subject: [PATCH 13/25] Address PR feedback

---
 .../2026-07-17-migrating-to-v4.md             | 102 +++------
 .../2026-07-20-whats-new-in-v4.md             | 204 +++++++-----------
 2 files changed, 104 insertions(+), 202 deletions(-)

diff --git a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
index 5e1c7b378..2402a5c7a 100644
--- a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
+++ b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
@@ -15,8 +15,8 @@ thumbnail: thumbnail/mixed.jpg
 # Migrating to Plotly.js v4
 
 This is a quick checklist of code changes needed to update existing Plotly.js
-v3 charts for v4. For full detail on every new feature and breaking change
-(with images, background, and edge cases), see [What's New in Plotly.js
+v3 charts for v4. For full detail on every new feature and breaking change,
+see [What's New in Plotly.js
 v4](/javascript/guides/whats-new-in-v4/).
 
 Most figures will render without changes. The items below call out where
@@ -52,14 +52,21 @@ Consumers of the pre-built browser bundle are unaffected.
 
 ## Removed color inputs
 
-Three color-input formats no longer work — invalid inputs fall back to the
-attribute's default:
+Plotly.js colors now conform thoroughly to the [CSS standard](https://www.w3.org/TR/css-color-4/). As a result
+three color-input formats no longer behave as before. `hsv()` and bare-hex
+inputs are now invalid and fall back to the attribute's default; fractional
+`rgb()` is no longer rescaled and now renders near-black instead of the
+intended color:
 
 | Input | What to do |
 |---|---|
-| `hsv()` strings | Convert to `hsl()`, `hwb()`, hex, or `rgb()` |
+| `hsv()` / `hsva()` strings | Convert to `hsl()`, `hwb()`, hex, or `rgb()` |
 | `rgb()` / `rgba()` strings with 0–1 decimal fractions | Convert `'rgb(0.5, 0.5, 0.5)'` to `'rgb(128, 128, 128)'` (or any supported string form) |
-| Numeric color values (e.g. `color: 42`) | Convert to a color string |
+| Hex strings without a leading `#` (e.g. `'fff'`, `'F00'`) | Add the `#` (e.g. `'#fff'`, `'#F00'`) |
+
+Note that these formats only affect *string* colors. Numeric color arrays
+used for color mapping (e.g. `marker.color: [1, 2, 3, 4]` paired with a
+`colorscale`) are unchanged and remain valid.
 
 Auto-computed contrast colors (heatmap text, `insidetextfont` on
 bars/waterfall, sankey hover on dark BG) may also shift by a few RGB units
@@ -76,11 +83,7 @@ Config options removed from `Plotly.newPlot(gd, data, layout, config)`:
 | `showLink`, `linkText`, `sendData`, `showSources` | None — remove them |
 | `showEditInChartStudio` | `showSendToCloud` |
 
-The `editInChartStudio` modebar button is gone — switch to `sendChartToCloud`.
-The v3 alias `sendDataToCloud` for that button was also removed, so update
-any `modeBarButtonsToAdd: ['sendDataToCloud']` calls to use
-`'sendChartToCloud'`. The undocumented `stream: { token, maxpoints }` trace
-attribute is removed and now schema-rejected.
+The `editInChartStudio` modebar button is gone — switch to `showSendToCloud`.
 
 ```js
 // Before
@@ -96,25 +99,8 @@ Plotly.newPlot(gd, data, layout, {
 });
 ```
 
-Also removed: every schema attribute ending in `src` (`xsrc`, `ysrc`,
-`textsrc`, `marker.colorsrc`, …) plus `layout.hidesources`. These were
-Chart Studio data-reference hooks; delete them from any figures where they
-still appear.
-
-The `Plots.graphJson()` signature is simplified — drop the third `mode`
-argument if you were passing one:
-
-```js
-// Before
-const json = Plotly.Plots.graphJson(gd, opts, mode);
-
-// After
-const json = Plotly.Plots.graphJson(gd, opts);
-```
-
 The **"Share with Plotly Cloud" button (`sendChartToCloud`) is now on by
-default** and targets `cloud.plotly.com`. If you don't want the button
-visible, opt out:
+default**. If you don't want the button visible, it can be turned off as follows:
 
 ```js
 Plotly.newPlot(gd, data, layout, { showSendToCloud: false });
@@ -124,8 +110,8 @@ Plotly.newPlot(gd, data, layout, { showSendToCloud: false });
 
 ## Removed mapbox traces and subplots
 
-The legacy `mapbox`-based traces and subplot type are gone. Rename to the
-MapLibre-based `map` family. For deeper background on the switch, see [Mapbox
+The legacy Mapbox-based traces and subplot type are gone. Rename to the
+MapLibre-based `map` family. For more information, see [Mapbox
 to MapLibre migration](https://plotly.com/python/mapbox-to-maplibre/).
 
 | Removed | Replacement |
@@ -158,34 +144,34 @@ The attribute shape is unchanged — usually a straight rename works:
 ```
 
 Built-in style names still work but use different tile providers (Carto,
-ArcGIS, OpenStreetMap) — visual output will shift. Stamen styles
+ArcGIS, OpenStreetMap), so the visual appearance will change. Stamen styles
 (`stamen-terrain`, `-toner`, `-watercolor`) are no longer built in — they now
 require a Stadia API key. The `mapbox://styles/mapbox/...` short-form URL is
-no longer resolved.
+no longer supported.
 
 ---
 
 ## Country name lookup
 
-`locationmode: 'country names'` on `choropleth` and `scattergeo` traces now
-uses a stricter matcher. Strings that only matched previously via broad regex
-fragments (e.g. `'Republic of'`, `'Not Iran'`) no longer resolve — locations
-are skipped. Switch to a canonical country name, an alias, or an ISO-3 / ISO-2
-code.
+`locationmode: 'country names'` (on `choropleth` and `scattergeo` traces) now
+uses a different library for looking up names. The vast majority of country
+names are handled exactly the same with the new library; a small number of
+legacy entries have been removed. If a name isn't matching in a plot, switch
+to a [canonical country name, an alias, or an ISO-3 / ISO-2 code](https://github.com/plotly/country-iso-search/blob/878c3a8a140aade85e109088d3e8edbc34fcda9d/src/countries.ts).
 
 ---
 
 ## Auto-fitting on `map` and `geo` subplots
 
-Both subplot types now auto-fit their initial view to fit trace data.
+Both subplot types now auto-fit their initial view to trace data.
 
 **For `map` subplots** (`scattermap`, `densitymap`): set `map.fitbounds:
-false`, or set `map.center` / `map.zoom` explicitly, to opt out.
+false`, or set `map.center` / `map.zoom` explicitly, to disable auto-fit.
 
 **For `geo` subplots** (`scattergeo`, `choropleth`): `layout.geo.fitbounds`
 now defaults to `'locations'` (previously `false`). Set `fitbounds: false`, or
 set any view attribute (`center`, `projection.rotation`, `projection.scale`,
-`lonaxis.range`, `lataxis.range`), to opt out.
+`lonaxis.range`, `lataxis.range`), to disable auto-fit.
 
 Figures that already supply view attributes render unchanged.
 
@@ -204,17 +190,8 @@ Figures that already supply view attributes render unchanged.
 | Change | Detail |
 |---|---|
 | Marker icons now respect `marker.color` | To maintain the v3 behavior, pass `marker.color: 'black'` |
-| Maki icons load from `@mapbox/maki@8.2.0` via jsDelivr | A handful of icon names dropped between Maki 2.1 and 8.2 will 404 — swap to the nearest Maki 8 equivalent. |
-| Legend swatches always draw a circle | Regardless of `marker.symbol`. Selectors that styled the swatch path based on symbol name will now match a circle on map traces. |
-
----
-
-## Shape legend `line.dash`
-
-Filled-shape legend markers (`type: 'rect'`, `'circle'`, or filled paths with
-`showlegend: true`) now draw their outline using the shape's `line.dash`
-value, matching the on-plot shape. No code change needed unless you had output
-locked to the v3 solid-outline behavior.
+| Maki icons updated from from v2.1 to 8.2 | A handful of icon names were removed between v2.1 and v8.2. See the [list](https://labs.mapbox.com/maki-icons/) of available icons. |
+| Legend swatches always render | A bug prevented some legend swatches from rendering for some scattermap traces. The bug has been fixed.  |
 
 ---
 
@@ -230,9 +207,6 @@ independent-grid behavior:
 { yaxis2: { overlaying: 'y', side: 'right', tickmode: 'auto' } }
 ```
 
-Categorical / multicategory base axes are exempt — overlays over them keep
-defaulting to `'auto'`.
-
 ---
 
 ## `splom.axis.matches` default
@@ -246,23 +220,14 @@ specific splom, set `matches: false` on its axes explicitly.
 
 ## Sankey layout
 
-`@plotly/d3-sankey` was upgraded from 0.7.2 to 0.12.3. The schema is
-unchanged, but node y-positions and link paths shift for the same figure. No
-code change needed unless you had output locked to specific pixel positions.
-
-To pin node/link order (for animation or side-by-side comparisons), use the
-new `sankey.node.sort` and `sankey.link.sort` attributes with `'input'`.
-Defaults preserve v3-equivalent auto ordering.
+`@plotly/d3-sankey` was upgraded from 0.7.2 to 0.12.3. Node y-positions and link paths may  change slightly.
 
 ---
 
-## MathJax v2 dropped
+## MathJax v2 support removed
 
 Plotly.js now supports **MathJax v3 and v4** for LaTeX rendering. **MathJax
-v2 support has been removed** — figures using a v2 bundle will no longer
-render math expressions.
-
-If your page bundles MathJax v2, upgrade to v3 or v4:
+v2 support has been removed**. If your page bundles MathJax v2, upgrade to v3 or v4:
 
 ```html
 <!-- v3 -->
@@ -270,6 +235,3 @@ If your page bundles MathJax v2, upgrade to v3 or v4:
 <!-- or v4 -->
 <script src="https://cdn.jsdelivr.net/npm/mathjax@4/tex-svg.js"></script>
 ```
-
-The MathJax v3 and v4 syntax is unchanged, so no code changes to the call
-sites are needed once the correct bundle is loaded.
diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
index ea727a221..276a34151 100644
--- a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -80,7 +80,7 @@ Plotly.newPlot(gd, [{
 
 | Attribute | Values | Purpose |
 |---|---|---|
-| `x`, `y` | numeric arrays | Arrow anchor positions. `x0` + `dx` / `y0` + `dy` shorthand also supported for regular grids. |
+| `x`, `y` | numeric arrays | Arrow anchor positions. |
 | `u`, `v` | numeric arrays | Vector components at each `(x, y)`. |
 | `anchor` | `'tail'` (default) / `'tip'` / `'center'` | Which point of the arrow sits at `(x, y)`. |
 | `sizemode` | `'scaled'` (default) / `'raw'` | Normalize arrow lengths against the maximum vector length + point density, or draw them at their raw magnitude. |
@@ -136,13 +136,7 @@ A larger example showing arrows colored by magnitude:
 [#7854](https://github.com/plotly/plotly.js/pull/7854), and
 [#7909](https://github.com/plotly/plotly.js/pull/7909).*
 
-Plotly.js can now share the current figure to
-[Plotly Cloud](https://cloud.plotly.com) from a one-click modebar button.
-The button posts the figure's data and layout to `cloud.plotly.com` and
-returns a shareable URL — the successor to the old Chart Studio upload
-flow, but without the Chart Studio-specific config surface (`showLink`,
-`sendData`, `showSources`, etc. — those are all gone; see
-[Chart Studio APIs removed](#chart-studio-apis-removed)).
+Plotly.js now offers a modebar button which sends the current chart to [Plotly Cloud](https://cloud.plotly.com) to generate a shareable link. Sharing the chart opens Plotly Cloud in a new tab, where you can copy the sharing link and adjust visibility settings. A Plotly Cloud account is required.
 
 The button is enabled by default in v4:
 
@@ -161,13 +155,6 @@ The button is controlled by two config options:
 | `showSendToCloud` | `true` | Whether the "Share with Plotly Cloud" modebar button is rendered. |
 | `plotlyServerURL` | `'cloud.plotly.com'` | The endpoint the button posts to. Override to point at a self-hosted or alternate server. |
 
-The button's internal name (in `modeBarButtonsToAdd`, event handlers, etc.)
-is `sendChartToCloud`. In v3 both `sendChartToCloud` and the alias
-`sendDataToCloud` worked; in v4 the alias is removed — code that referred to
-the button by the `sendDataToCloud` name needs to be updated.
-
-### Opting out
-
 Hide the button by setting `showSendToCloud: false`:
 
 ```js
@@ -176,30 +163,6 @@ Plotly.newPlot(gd, data, layout, {
 });
 ```
 
-Or point the upload at a different host:
-
-```js
-Plotly.newPlot(gd, data, layout, {
-    plotlyServerURL: 'https://my-plotly-mirror.example.com'
-});
-```
-
-### Endpoint status
-
-The `cloud.plotly.com` endpoint is **not yet functional at the v4 release**.
-The button renders and is wired up, but clicking it does not complete an
-upload until the endpoint is deployed. Once it goes live, existing figures
-running v4 with the default config will start supporting uploads without
-any code change on the caller side.
-
-### History
-
-The upload flow was built out across the Plotly.js 3.7 series
-(#7802 / #7852 / #7854), but shipped with `showSendToCloud` defaulting to
-`false`, so unless you set the flag manually you never saw the button.
-v4 (#7909) flips the default so every new figure exposes it by default —
-this is a functional feature reveal, not a new API.
-
 ---
 
 ## MathJax v4 support
@@ -207,33 +170,24 @@ this is a functional feature reveal, not a new API.
 *Implemented in [#7898](https://github.com/plotly/plotly.js/pull/7898).*
 
 Plotly.js now supports **MathJax v3 and v4** for rendering LaTeX in labels,
-titles, annotations, and hover text. Support for **MathJax v2 has been
-dropped** — figures that rely on a v2 bundle will no longer render their math
-expressions.
-
-MathJax v3 and v4 share the same rendering syntax, so Plotly no longer needs
-version-specific code paths internally. Beyond dropping v2, the internal
-`svg_text_utils.js` rewrite makes math rendering somewhat faster.
+titles, and annotations. Support for **MathJax v2 has been dropped**.
 
 ### What to do
 
-- Loading MathJax v2 in the page? Upgrade to v3 or v4. The tex-svg build is
-  the one Plotly integrates with:
-  ```html
-  <!-- v3 (still supported) -->
-  <script src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js"></script>
-  <!-- or v4 (new) -->
-  <script src="https://cdn.jsdelivr.net/npm/mathjax@4/tex-svg.js"></script>
-  ```
-- Already on v3? No action required — your math expressions continue to
-  render.
-- On v4 already? No action required either.
+Loading MathJax v2 in the page? Upgrade to v3 or v4. Plotly math rendering
+uses the tex-svg component (`tex-svg.js`):
+```html
+<!-- v3 (still supported) -->
+<script src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js"></script>
+<!-- or v4 (new) -->
+<script src="https://cdn.jsdelivr.net/npm/mathjax@4/tex-svg.js"></script>
+```
 
-### Call sites unchanged
+Note that the `?config=TeX-AMS-MML_SVG` URL suffix (used with MathJax v2) is
+no longer required starting with MathJax v3. Configuration is specified by linking
+directly to the desired JavaScript file, which is `tex-svg.js` for Plotly.js.
 
-Plotly's public API for math (using `$…$` in text attributes) is unchanged.
-The version negotiation happens inside Plotly at runtime — the correct
-rendering path is chosen based on what MathJax exposes.
+Already on v3? No action required — your math expressions continue to render.
 
 ---
 
@@ -792,37 +746,42 @@ the process.
 A color in the unsupported format will fall back to the attribute's default.
 
 **`rgb()` / `rgba()` strings with 0–1 decimal fractions are no longer
-accepted.**
+rescaled.** In v3, Plotly detected all-fractional `rgb()` components and
+rescaled them from 0–1 to 0–255 before parsing; v4 removed that step and reads
+every component literally on the 0–255 scale, so the same string now renders
+near-black.
 
 ```js
-// Before — tinycolor parsed this as 0–1 fractions
+// Before — v3 rescaled 0–1 fractions to 0–255
 'rgb(0.5, 0.5, 0.5)'  // → rgb(128, 128, 128)
 
-// After — the underlying library reads them on the 0–255 scale and rounds
-// to the nearest integer
+// After — read literally on the 0–255 scale and rounded to the nearest integer
 'rgb(0.5, 0.5, 0.5)'  // → rgb(1, 1, 1)
 ```
 
 Convert any inputs of the form `rgb(0.5, 0.5, 0.5)` to `rgb(128, 128, 128)`
 (or any other supported color string) before passing them to Plotly.
 
-Every numeric component is read literally on the 0–255 scale and rounded —
-there is no 0–1 fraction detection. A string like `rgb(255, 0.0, 0.0)` still
-renders correctly because its `0.0` components round to `0`, but any genuinely
-fractional component rounds to the nearest integer rather than scaling to
-0–255 (e.g. `rgb(200, 0.5, 0.5)` → `rgb(200, 1, 1)`).
+Rescaling only ever applied when *all* of `r`, `g`, `b` were fractional. A
+string like `rgb(255, 0.0, 0.0)` was never rescaled and still renders
+correctly (its `0.0` components round to `0`); a partly-fractional string such
+as `rgb(200, 0.5, 0.5)` now rounds each component to the nearest integer →
+`rgb(200, 1, 1)`.
 
-**Numeric color inputs are now rejected.**
+**Hex strings without a leading `#` are no longer accepted.**
 
 ```js
-// Before — silently accepted, rendered as near-black
-{ marker: { color: 42 } }
+// Before — tinycolor accepted bare hex
+{ marker: { color: 'fff' } }
 
-// After — falls back to the attribute default
+// After — invalid and falls back to the attribute default; add the '#'
+{ marker: { color: '#fff' } }
 ```
 
-If you were relying on numeric color values being coerced, convert them to
-color strings before passing them to Plotly.
+These changes affect *string* colors only. Numeric color arrays used for color
+mapping (e.g. `marker.color: [1, 2, 3, 4]` with a `colorscale`) are unchanged
+and remain valid — those values are mapped through the colorscale, not parsed
+as literal colors.
 
 ### Color computation output changes
 
@@ -846,19 +805,22 @@ different formula.
 
 ### New color formats you can now use
 
-The new library accepts CSS Color 4 syntax that wasn't possible with
-tinycolor. All of these are now valid anywhere Plotly accepts a color string:
+The new library adds CSS Color 4 syntax that tinycolor didn't fully support —
+notably slash-separated alpha and the `hwb()` color space:
 
 ```js
-'#ff0000aa'          // 8-digit hex with alpha
-'#f00a'              // 4-digit short hex with alpha
-'rgb(255 0 0)'       // space-separated rgb
-'rgba(255 0 0 / 0.5)' // slash-alpha rgba
-'hsl(0 100% 50% / 0.5)' // slash-alpha hsl
-'hsla(0, 100%, 50%, 0.5)' // hsla
-'hwb(0, 0%, 0%)'     // hwb (hue-whiteness-blackness)
+'rgba(255 0 0 / 0.5)'     // space-separated rgb with slash alpha
+'hsl(0 100% 50% / 0.5)'   // slash alpha on hsl (v3 accepted the syntax but dropped the alpha)
+'hwb(0, 0%, 0%)'          // hwb (hue-whiteness-blackness)
 ```
 
+The following additional formats were already supported:
+
+- 8-digit hex (`#ff0000aa`)
+- 4-digit short hex (`#f00a`),
+- Space-separated `rgb(255 0 0)`
+- Comma-form `hsla(0, 100%, 50%, 0.5)`.
+
 See
 [test/image/mocks/color_syntax_formats.json](https://github.com/plotly/plotly.js/blob/master/test/image/mocks/color_syntax_formats.json)
 for a working example using each format.
@@ -1149,34 +1111,15 @@ These existed only to interoperate with Chart Studio's data-source
 references, which is no longer reachable. If your figures contain any
 `*src` attributes or `hidesources`, delete them — they're now schema-rejected.
 
-### `Plots.graphJson()` signature simplified
-
-*See [#7829](https://github.com/plotly/plotly.js/pull/7829).*
-
-`Plotly.Plots.graphJson()` previously accepted a `mode` argument that was
-Chart Studio–specific. It has been dropped:
-
-```js
-// Before
-const json = Plotly.Plots.graphJson(gd, opts, mode);
-
-// After
-const json = Plotly.Plots.graphJson(gd, opts);
-```
-
-If you were passing the third argument (typically `'keepdata'` or
-`'keepall'`), remove it — that behavior was only meaningful when uploading
-to Chart Studio.
-
 ---
 
 ## Mapbox traces and subplots removed
 
 *Implemented in [#7860](https://github.com/plotly/plotly.js/pull/7860).*
 
-The legacy mapbox-gl-js–based traces and subplot type have been removed. The
-MapLibre-based `map` family that has shadowed them since v2 is now the only
-map implementation. For deeper background on the switch, see [Mapbox to
+The legacy Mapbox–based traces and subplot type have been removed. The
+equivalent MapLibre-based `map` traces (first released in Plotly.js v3) are
+now the only map implementation. For more information, see [Mapbox to
 MapLibre migration](https://plotly.com/python/mapbox-to-maplibre/).
 
 ### Removed
@@ -1193,9 +1136,8 @@ MapLibre migration](https://plotly.com/python/mapbox-to-maplibre/).
 | Modebar buttons `zoomInMapbox`, `zoomOutMapbox`, `resetViewMapbox` | `zoomInMap`, `zoomOutMap`, `resetViewMap` |
 | `scrollZoom` flag value `'mapbox'` (e.g. `scrollZoom: 'mapbox+cartesian'`) | `'map'` |
 
-The schema for `map` mirrors `mapbox` attribute-for-attribute (`domain`,
-`style`, `center`, `zoom`, `bearing`, `pitch`, `bounds`, `layers[...]`), so
-the migration is usually a rename.
+The attributes for `map` traces are identical to those of `mapbox` traces, so
+updating the trace name is all that's required to migrate.
 
 ```js
 // Before
@@ -1221,36 +1163,35 @@ the migration is usually a rename.
             zoom: 2,
         },
     },
-    // mapboxAccessToken removed — MapLibre needs no token for the
-    // built-in styles
+    // mapboxAccessToken no longer required
 }
 ```
 
 ### Built-in style values
 
-Every built-in `style` name that worked on `mapbox` still works on `map`, but
-the tiles backing them differ — visual output **will change** even when no
-other figure changes:
+Every built-in `style` value supported for `mapbox` traces works for `map` traces as well,
+but the tile providers for some styles have changed. In those cases, the visual appearance
+of the map will differ:
 
 | Style name | Old (`mapbox`) | New (`map`) |
 |---|---|---|
-| `basic`, `streets`, `outdoors` | mapbox.com vector tiles (required token) | Carto Voyager |
-| `light` | mapbox.com light | Carto Positron |
-| `dark` | mapbox.com dark | Carto Dark Matter |
-| `satellite`, `satellite-streets` | mapbox.com satellite | ArcGIS World Imagery |
-| `white-bg`, `open-street-map` | unchanged | unchanged |
-| `carto-*`, `carto-*-nolabels` | n/a (already open) | unchanged |
-
-The three Stamen styles (`stamen-terrain`, `stamen-toner`,
-`stamen-watercolor`) are gone — Stamen tiles now require a Stadia API key.
-Users who need them can supply a custom `style` URL.
+| `'basic'`, `'streets'`, `'outdoors'` | mapbox.com 'basic' / 'streets' / 'outdoors'  tiles | [Carto](https://github.com/cartodb/basemap-styles/) Voyager |
+| `'light'` | mapbox.com 'light' tiles | [Carto](https://github.com/cartodb/basemap-styles/) Positron |
+| `'dark'` | mapbox.com 'dark' tiles | [Carto](https://github.com/cartodb/basemap-styles/) Dark Matter |
+| `'satellite'`, `satellite-streets` | mapbox.com satellite tiles | [ArcGIS World Imagery](https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer) |
+| `'white-bg'` | solid white background | unchanged |
+| `'open-street-map'` | [OpenStreetMap](https://www.openstreetmap.org) tiles | unchanged |
+| `carto-*`, `carto-*-nolabels` | Corresponding [Carto](https://github.com/cartodb/basemap-styles/) tiles | unchanged |
+
+The three Stamen style values (`stamen-terrain`, `stamen-toner`, `stamen-watercolor`)
+are no longer supported, since Stamen tiles require a Stadia API key. It is still possible to use
+Stamen tiles, or any other third-party tiles, by passing the URL of a JSON style definition to `style`.
 
 ### Custom style URLs
 
-Custom MapLibre / Mapbox-style JSON URLs continue to work. The
-`mapbox://styles/mapbox/...` short form is no longer resolved, since it
-requires authenticating to mapbox.com. Substitute the full URL of an
-equivalent open style, or self-host the style JSON.
+Setting `style` to the URL of a MapLibre / Mapbox JSON style definition is still supported.
+Custom Mapbox URLs of the form `mapbox://styles/mapbox/...` are no longer supported, since they
+require authenticating to mapbox.com.
 
 ---
 
@@ -1258,7 +1199,7 @@ equivalent open style, or self-host the style JSON.
 
 *Implemented in [#7861](https://github.com/plotly/plotly.js/pull/7861).*
 
-Plotly.js now requires Node.js v22 or newer. The previous floor was v18, which
+Plotly.js now requires Node.js v22 or newer. The previous minimum was v18, which
 has reached end-of-life.
 
 This only affects you if:
@@ -1270,8 +1211,7 @@ This only affects you if:
 | You install via `yarn` or `pnpm` | Both enforce `engines` strictly (`npm` prints a warning but installs) |
 
 Consumers who only load the pre-built browser bundle (`plotly.min.js` or a
-partial bundle like `plotly-basic.min.js`) are unaffected — the bundle runs in
-browsers, not Node.
+partial bundle like `plotly-basic.min.js`) are unaffected.
 
 If you're on Node 18 or 20, upgrade to 22 LTS. `npm` will print a warning on
 install but won't fail; `yarn` and `pnpm` will refuse to install unless your

From 887b37d16e16deae696459f3ff02dce7bf46413a Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 5 Aug 2026 09:45:44 -0600
Subject: [PATCH 14/25] Clarify colors, add links to new pages

---
 .../2026-07-17-migrating-to-v4.md             | 10 +++---
 .../2026-07-20-whats-new-in-v4.md             | 32 +++++++++++++++----
 2 files changed, 32 insertions(+), 10 deletions(-)

diff --git a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
index 2402a5c7a..22f76179e 100644
--- a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
+++ b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
@@ -53,7 +53,7 @@ Consumers of the pre-built browser bundle are unaffected.
 ## Removed color inputs
 
 Plotly.js colors now conform thoroughly to the [CSS standard](https://www.w3.org/TR/css-color-4/). As a result
-three color-input formats no longer behave as before. `hsv()` and bare-hex
+the following color-input formats no longer behave as before. `hsv()` and bare-hex
 inputs are now invalid and fall back to the attribute's default; fractional
 `rgb()` is no longer rescaled and now renders near-black instead of the
 intended color:
@@ -61,12 +61,14 @@ intended color:
 | Input | What to do |
 |---|---|
 | `hsv()` / `hsva()` strings | Convert to `hsl()`, `hwb()`, hex, or `rgb()` |
+| `hsl()` / `hsla()` strings without percent units on saturation and lightness (e.g. `'hsl(0, 100, 40)'`, `'hsl(0 100 40)'`) | Add the units (e.g. `'hsl(0, 100%, 40%)'`) |
 | `rgb()` / `rgba()` strings with 0–1 decimal fractions | Convert `'rgb(0.5, 0.5, 0.5)'` to `'rgb(128, 128, 128)'` (or any supported string form) |
 | Hex strings without a leading `#` (e.g. `'fff'`, `'F00'`) | Add the `#` (e.g. `'#fff'`, `'#F00'`) |
 
 Note that these formats only affect *string* colors. Numeric color arrays
 used for color mapping (e.g. `marker.color: [1, 2, 3, 4]` paired with a
-`colorscale`) are unchanged and remain valid.
+`colorscale`) are unchanged and remain valid. For the full list of formats
+Plotly.js accepts, see [Specifying Colors](/javascript/colors/).
 
 Auto-computed contrast colors (heatmap text, `insidetextfont` on
 bars/waterfall, sankey hover on dark BG) may also shift by a few RGB units
@@ -190,8 +192,8 @@ Figures that already supply view attributes render unchanged.
 | Change | Detail |
 |---|---|
 | Marker icons now respect `marker.color` | To maintain the v3 behavior, pass `marker.color: 'black'` |
-| Maki icons updated from from v2.1 to 8.2 | A handful of icon names were removed between v2.1 and v8.2. See the [list](https://labs.mapbox.com/maki-icons/) of available icons. |
-| Legend swatches always render | A bug prevented some legend swatches from rendering for some scattermap traces. The bug has been fixed.  |
+| Maki icons updated from v2.1 to 8.2 | A handful of icon names were removed between v2.1 and v8.2. See the [list](https://labs.mapbox.com/maki-icons/) of available icons. |
+| Legend swatches always draw a circle | Regardless of `marker.symbol`. In v3, symbols whose names overlap the Plotly set (`'square'`, `'star'`, …) drew broken or empty swatch paths; those now render as circles, consistent with every other scattermap trace. |
 
 ---
 
diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
index 276a34151..2f7a9292a 100644
--- a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -62,7 +62,8 @@ v4](/javascript/guides/migrating-to-v4/).
 
 Plotly.js now ships a `quiver` trace type for visualizing 2D vector fields as
 arrays of arrows. Arrows are placed at `(x, y)` coordinates and drawn with
-direction and magnitude from `(u, v)` components.
+direction and magnitude from `(u, v)` components. See
+[Quiver Plots](/javascript/quiver-plots/) for runnable examples.
 
 ```js
 Plotly.newPlot(gd, [{
@@ -196,7 +197,8 @@ Already on v3? No action required — your math expressions continue to render.
 *Implemented in [#7873](https://github.com/plotly/plotly.js/pull/7873).*
 
 Two new attributes let you override the automatic ordering that v4's d3-sankey
-algorithm applies:
+algorithm applies (see [Node and Link
+Ordering](/javascript/sankey-diagram/#node-and-link-ordering)):
 
 | Attribute | Default | `'input'` value |
 |---|---|---|
@@ -246,7 +248,8 @@ flips the source column to `D, C, B, A` so the primary flows run horizontally;
 
 A new `sankey.direction` attribute controls which way flows run along the
 `orientation` axis, so you can reverse a diagram without manually reversing
-your `link.source` / `link.target` data.
+your `link.source` / `link.target` data (see [Flow
+Direction](/javascript/sankey-diagram/#flow-direction)).
 
 | Attribute | Default | `'reversed'` value |
 |---|---|---|
@@ -294,7 +297,8 @@ geometry mirrors.
 
 *Implemented in [#7371](https://github.com/plotly/plotly.js/pull/7371).*
 
-Geo subplots accept two new attributes for clamping interactive zoom:
+Geo subplots accept two new attributes for clamping interactive zoom (see
+[Limiting Zoom on Outline Maps](/javascript/map-view/#limiting-zoom-on-outline-maps)):
 
 | Attribute | Default | Effect |
 |---|---|---|
@@ -333,7 +337,9 @@ bounds.
 
 Plotly.js now ships its own TypeScript type definitions. `package.json` points
 `"types"` at `lib/index.d.ts`, so the types are picked up automatically — no
-separate `@types/*` install is needed.
+separate `@types/*` install is needed. See
+[Using Plotly.js with TypeScript](/javascript/guides/typescript/) for a
+task-oriented walkthrough.
 
 ### Importing
 
@@ -745,6 +751,17 @@ the process.
 
 A color in the unsupported format will fall back to the attribute's default.
 
+**`hsl()` / `hsla()` strings need percent units on saturation and lightness.**
+A color in the unsupported format will fall back to the attribute's default.
+
+```js
+// Before
+{ marker: { color: 'hsl(0, 100, 40)' } }
+
+// After — add the percent units
+{ marker: { color: 'hsl(0, 100%, 40%)' } }
+```
+
 **`rgb()` / `rgba()` strings with 0–1 decimal fractions are no longer
 rescaled.** In v3, Plotly detected all-fractional `rgb()` components and
 rescaled them from 0–1 to 0–255 before parsing; v4 removed that step and reads
@@ -811,9 +828,12 @@ notably slash-separated alpha and the `hwb()` color space:
 ```js
 'rgba(255 0 0 / 0.5)'     // space-separated rgb with slash alpha
 'hsl(0 100% 50% / 0.5)'   // slash alpha on hsl (v3 accepted the syntax but dropped the alpha)
-'hwb(0, 0%, 0%)'          // hwb (hue-whiteness-blackness)
+'hwb(0 0% 0%)'            // hwb (hue-whiteness-blackness)
 ```
 
+Note that `hwb()` has no comma-separated form in CSS — the legacy syntax exists
+only for `rgb()` and `hsl()`.
+
 The following additional formats were already supported:
 
 - 8-digit hex (`#ff0000aa`)

From 430d73793be8aaedf7e086b9752c659468c0b482 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 5 Aug 2026 09:47:18 -0600
Subject: [PATCH 15/25] Update plotly.js to v4.0.0-rc.0

---
 _data/jsversion.json  |     2 +-
 _data/plotschema.json | 57335 ++++++++++++++++------------------------
 2 files changed, 22064 insertions(+), 35273 deletions(-)

diff --git a/_data/jsversion.json b/_data/jsversion.json
index ed344f47d..fc7c93fcc 100644
--- a/_data/jsversion.json
+++ b/_data/jsversion.json
@@ -1,3 +1,3 @@
 {
-  "version": "3.6.0"
+  "version": "4.0.0-rc.0"
 }
\ No newline at end of file
diff --git a/_data/plotschema.json b/_data/plotschema.json
index 47745dbbd..f4e5d9a66 100644
--- a/_data/plotschema.json
+++ b/_data/plotschema.json
@@ -141,7 +141,7 @@
       ]
     },
     "doubleClickDelay": {
-      "description": "Sets the delay for registering a double-click in ms. This is the time interval (in ms) between first mousedown and 2nd mouseup to constitute a double-click. This setting propagates to all on-subplot double clicks (except for geo, mapbox and map) and on-legend double clicks.",
+      "description": "Sets the delay for registering a double-click in ms. This is the time interval (in ms) between first mousedown and 2nd mouseup to constitute a double-click. This setting propagates to all on-subplot double clicks (except for geo and map) and on-legend double clicks.",
       "dflt": 300,
       "min": 0,
       "valType": "number"
@@ -221,12 +221,6 @@
       "min": 0,
       "valType": "number"
     },
-    "linkText": {
-      "description": "Sets the text appearing in the `showLink` link.",
-      "dflt": "Edit chart",
-      "noBlank": true,
-      "valType": "string"
-    },
     "locale": {
       "description": "Which localization should we use? Should be a string like 'en' or 'en-US'.",
       "dflt": "en-US",
@@ -244,11 +238,6 @@
       "min": 0,
       "valType": "integer"
     },
-    "mapboxAccessToken": {
-      "description": "Mapbox access token (required to plot mapbox trace types) If using an Mapbox Atlas server, set this option to '' so that plotly.js won't attempt to authenticate to the public Mapbox server.",
-      "dflt": null,
-      "valType": "string"
-    },
     "modeBarButtons": {
       "description": "Define fully custom mode bar buttons as nested array, where the outer arrays represents button groups, and the inner arrays have buttons config objects or names of default buttons See ./components/modebar/buttons.js for more info.",
       "dflt": false,
@@ -279,8 +268,8 @@
       "valType": "number"
     },
     "plotlyServerURL": {
-      "description": "When set it determines base URL for the 'Edit in Chart Studio' `showEditInChartStudio`/`showSendToCloud` mode bar button and the showLink/sendData on-graph link. To enable sending your data to Chart Studio Cloud, you need to set both `plotlyServerURL` to 'https://chart-studio.plotly.com' and also set `showSendToCloud` to true.",
-      "dflt": "",
+      "description": "Sets the URL for the `sendChartToCloud` modebar button. When clicked, the button will send the chart data to this URL.",
+      "dflt": "https://cloud.plotly.com/newchart",
       "valType": "string"
     },
     "queueLength": {
@@ -295,7 +284,7 @@
       "valType": "boolean"
     },
     "scrollZoom": {
-      "description": "Determines whether mouse wheel or two-finger scroll zooms is enable. Turned on by default for gl3d, geo, mapbox and map subplots (as these subplot types do not have zoombox via pan), but turned off by default for cartesian subplots. Set `scrollZoom` to *false* to disable scrolling for all subplots.",
+      "description": "Determines whether mouse wheel or two-finger scroll zooms is enable. Turned on by default for gl3d, geo and map subplots (as these subplot types do not have zoombox via pan), but turned off by default for cartesian subplots. Set `scrollZoom` to *false* to disable scrolling for all subplots.",
       "dflt": "gl3d+geo+map",
       "extras": [
         true,
@@ -305,16 +294,10 @@
         "cartesian",
         "gl3d",
         "geo",
-        "mapbox",
         "map"
       ],
       "valType": "flaglist"
     },
-    "sendData": {
-      "description": "If *showLink* is true, does it contain data just link to a Chart Studio Cloud file?",
-      "dflt": true,
-      "valType": "boolean"
-    },
     "setBackground": {
       "description": "Set function to add the background color (i.e. `layout.paper_color`) to a different container. This function take the graph div as first argument and the current background color as second argument. Alternatively, set to string *opaque* to ensure there is white behind it.",
       "dflt": "transparent",
@@ -330,26 +313,11 @@
       "dflt": true,
       "valType": "boolean"
     },
-    "showEditInChartStudio": {
-      "description": "Same as `showSendToCloud`, but use a pencil icon instead of a floppy-disk. Note that if both `showSendToCloud` and `showEditInChartStudio` are turned, only `showEditInChartStudio` will be honored.",
-      "dflt": false,
-      "valType": "boolean"
-    },
-    "showLink": {
-      "description": "Determines whether a link to Chart Studio Cloud is displayed at the bottom right corner of resulting graphs. Use with `sendData` and `linkText`.",
-      "dflt": false,
-      "valType": "boolean"
-    },
     "showSendToCloud": {
-      "description": "Should we include a ModeBar button, labeled \"Edit in Chart Studio\", that sends this chart to chart-studio.plotly.com (formerly plot.ly) or another plotly server as specified by `plotlyServerURL` for editing, export, etc? Prior to version 1.43.0 this button was included by default, now it is opt-in using this flag. Note that this button can (depending on `plotlyServerURL` being set) send your data to an external server. However that server does not persist your data until you arrive at the Chart Studio and explicitly click \"Save\".",
-      "dflt": false,
+      "description": "Should we include a modebar button that sends this chart to a URL specified by `plotlyServerURL`, for sharing the chart with others? Note that this button will (after a confirmation step) send chart data to an external server.",
+      "dflt": true,
       "valType": "boolean"
     },
-    "showSources": {
-      "description": "Adds a source-displaying function to show sources on the resulting graphs.",
-      "dflt": false,
-      "valType": "any"
-    },
     "showTips": {
       "description": "Determines whether or not tips are shown while interacting with the resulting graphs.",
       "dflt": true,
@@ -372,7 +340,7 @@
       "valType": "string"
     },
     "typesetMath": {
-      "description": "Determines whether math should be typeset or not, when MathJax (either v2 or v3) is present on the page.",
+      "description": "Determines whether math should be typeset or not, when MathJax (either v3 or v4) is present on the page.",
       "dflt": true,
       "valType": "boolean"
     },
@@ -459,7 +427,7 @@
         "requiredOpts": []
       },
       "color": {
-        "description": "A string describing color. Supported formats: - hex (e.g. '#d3d3d3') - rgb (e.g. 'rgb(255, 0, 0)') - rgba (e.g. 'rgb(255, 0, 0, 0.5)') - hsl (e.g. 'hsl(0, 100%, 50%)') - hsv (e.g. 'hsv(0, 100%, 100%)') - named colors (full list: http://www.w3.org/TR/css3-color/#svg-color)",
+        "description": "A string describing color. Supported formats: - hex (e.g. '#d3d3d3', '#d3d3d3aa') - rgb (e.g. 'rgb(255, 0, 0)', 'rgb(255 0 0)') - rgba (e.g. 'rgba(255, 0, 0, 0.5)', 'rgba(255 0 0 / 0.5)') - hsl (e.g. 'hsl(0, 100%, 50%)') - hsla (e.g. 'hsla(0, 100%, 50%, 0.5)') - hwb (e.g. 'hwb(0, 0%, 0%)') - named colors (full list: http://www.w3.org/TR/css3-color/#svg-color)",
         "otherOpts": [
           "dflt",
           "arrayOk"
@@ -499,7 +467,7 @@
         ]
       },
       "flaglist": {
-        "description": "A string representing a combination of flags (order does not matter here). Combine any of the available `flags` with *+*. (e.g. ('lines+markers')). Values in `extras` cannot be combined.",
+        "description": "A string representing a combination of flags (flag order does not affect the output). Combine any of the available `flags` with *+*. (e.g. ('lines+markers')). Values in `extras` cannot be combined.",
         "otherOpts": [
           "dflt",
           "extras",
@@ -2363,22 +2331,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_coloraxes(colorbar_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "colorbars",
             "valType": "data_array",
             "magic_underscores": "fig.update_coloraxes(colorbar_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -2490,7 +2448,7 @@
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
@@ -2583,7 +2541,7 @@
           "magic_underscores": "fig.update_coloraxes(colorbar=dict(...))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
@@ -2627,11 +2585,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_layout(modebar_add=&lt;VALUE&gt;)"
         },
-        "addsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `add`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "bgcolor": {
           "description": "Sets the background color of the modebar.",
           "editType": "modebar",
@@ -2658,17 +2611,12 @@
         },
         "remove": {
           "arrayOk": true,
-          "description": "Determines which predefined modebar buttons to remove. Similar to `config.modeBarButtonsToRemove` option. This may include *autoScale2d*, *autoscale*, *editInChartStudio*, *editinchartstudio*, *hoverCompareCartesian*, *hovercompare*, *lasso*, *lasso2d*, *orbitRotation*, *orbitrotation*, *pan*, *pan2d*, *pan3d*, *reset*, *resetCameraDefault3d*, *resetCameraLastSave3d*, *resetGeo*, *resetSankeyGroup*, *resetScale2d*, *resetViewMap*, *resetViewMapbox*, *resetViews*, *resetcameradefault*, *resetcameralastsave*, *resetsankeygroup*, *resetscale*, *resetview*, *resetviews*, *select*, *select2d*, *sendDataToCloud*, *senddatatocloud*, *tableRotation*, *tablerotation*, *toImage*, *toggleHover*, *toggleSpikelines*, *togglehover*, *togglespikelines*, *toimage*, *zoom*, *zoom2d*, *zoom3d*, *zoomIn2d*, *zoomInGeo*, *zoomInMap*, *zoomInMapbox*, *zoomOut2d*, *zoomOutGeo*, *zoomOutMap*, *zoomOutMapbox*, *zoomin*, *zoomout*.",
+          "description": "Determines which predefined modebar buttons to remove. Similar to `config.modeBarButtonsToRemove` option. This may include *autoScale2d*, *autoscale*, *hoverCompareCartesian*, *hovercompare*, *lasso*, *lasso2d*, *orbitRotation*, *orbitrotation*, *pan*, *pan2d*, *pan3d*, *reset*, *resetCameraDefault3d*, *resetCameraLastSave3d*, *resetGeo*, *resetSankeyGroup*, *resetScale2d*, *resetViewMap*, *resetViews*, *resetcameradefault*, *resetcameralastsave*, *resetsankeygroup*, *resetscale*, *resetview*, *resetviews*, *select*, *select2d*, *sendChartToCloud*, *sendcharttocloud*, *tableRotation*, *tablerotation*, *toImage*, *toggleHover*, *toggleSpikelines*, *togglehover*, *togglespikelines*, *toimage*, *zoom*, *zoom2d*, *zoom3d*, *zoomIn2d*, *zoomInGeo*, *zoomInMap*, *zoomOut2d*, *zoomOutGeo*, *zoomOutMap*, *zoomin*, *zoomout*.",
           "dflt": "",
           "editType": "modebar",
           "valType": "string",
           "magic_underscores": "fig.update_layout(modebar_remove=&lt;VALUE&gt;)"
         },
-        "removesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `remove`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "role": "object",
         "uirevision": {
           "description": "Controls persistence of user-driven changes related to the modebar, including `hovermode`, `dragmode`, and `showspikes` at both the root level and inside subplots. Defaults to `layout.uirevision`.",
@@ -3217,11 +3165,6 @@
         "valType": "any",
         "magic_underscores": "fig.update_layout(meta=&lt;VALUE&gt;)"
       },
-      "metasrc": {
-        "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-        "editType": "none",
-        "valType": "string"
-      },
       "computed": {
         "description": "Placeholder for exporting automargin-impacting values namely `margin.t`, `margin.b`, `margin.l` and `margin.r` in *full-json* mode.",
         "editType": "none",
@@ -3524,7 +3467,7 @@
           "editType": "plot",
           "include": {
             "arrayOk": true,
-            "description": "Ensure this value is included in autorange.",
+            "description": "Extends the autorange to include this value or array of values, even when they fall outside the data range. Has no effect on endpoints set by `autorangeoptions.minallowed` or `autorangeoptions.maxallowed`. Subject to `autorangeoptions.clipmin` and `autorangeoptions.clipmax`.",
             "editType": "plot",
             "impliedEdits": {
               "magic_underscores": "fig.update_xaxes(autorangeoptions_include_impliedEdits=&lt;VALUE&gt;)"
@@ -3532,11 +3475,6 @@
             "valType": "any",
             "magic_underscores": "fig.update_xaxes(autorangeoptions_include=&lt;VALUE&gt;)"
           },
-          "includesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `include`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "maxallowed": {
             "description": "Use this value exactly as autorange maximum.",
             "editType": "plot",
@@ -3615,11 +3553,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_xaxes(categoryarray=&lt;VALUE&gt;)"
         },
-        "categoryarraysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "categoryorder": {
           "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`. Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the numerical order of the values. Similarly, the order can be determined by the min, max, sum, mean, geometric mean or median of all the values.",
           "dflt": "trace",
@@ -3985,11 +3918,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_xaxes(minor_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "editType": "ticks",
@@ -4666,7 +4594,7 @@
           "magic_underscores": "fig.update_xaxes(spikedash=&lt;VALUE&gt;)"
         },
         "spikemode": {
-          "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the  series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on",
+          "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on",
           "dflt": "toaxis",
           "editType": "none",
           "flags": [
@@ -4880,11 +4808,6 @@
           "valType": "integer",
           "magic_underscores": "fig.update_xaxes(ticklabelindex=&lt;VALUE&gt;)"
         },
-        "ticklabelindexsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ticklabelindex`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "ticklabelmode": {
           "description": "Determines where tick labels are drawn with respect to their corresponding ticks and grid lines. Only has an effect for axes of `type` *date* When set to *period*, tick labels are drawn in the middle of the period between ticks.",
           "dflt": "instant",
@@ -4957,7 +4880,7 @@
           "magic_underscores": "fig.update_xaxes(ticklen=&lt;VALUE&gt;)"
         },
         "tickmode": {
-          "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property.",
+          "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property. When no other tick info is provided, overlaying (non-categorical) axes default to *sync*, while other axes default to *auto*.",
           "editType": "ticks",
           "impliedEdits": {
             "magic_underscores": "fig.update_xaxes(tickmode_impliedEdits=&lt;VALUE&gt;)"
@@ -5013,22 +4936,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_xaxes(ticktext=&lt;VALUE&gt;)"
         },
-        "ticktextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "tickvals": {
           "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
           "editType": "ticks",
           "valType": "data_array",
           "magic_underscores": "fig.update_xaxes(tickvals=&lt;VALUE&gt;)"
         },
-        "tickvalssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "tickwidth": {
           "description": "Sets the tick width (in px).",
           "dflt": 1,
@@ -5300,7 +5213,7 @@
           "editType": "plot",
           "include": {
             "arrayOk": true,
-            "description": "Ensure this value is included in autorange.",
+            "description": "Extends the autorange to include this value or array of values, even when they fall outside the data range. Has no effect on endpoints set by `autorangeoptions.minallowed` or `autorangeoptions.maxallowed`. Subject to `autorangeoptions.clipmin` and `autorangeoptions.clipmax`.",
             "editType": "plot",
             "impliedEdits": {
               "magic_underscores": "fig.update_yaxes(autorangeoptions_include_impliedEdits=&lt;VALUE&gt;)"
@@ -5308,11 +5221,6 @@
             "valType": "any",
             "magic_underscores": "fig.update_yaxes(autorangeoptions_include=&lt;VALUE&gt;)"
           },
-          "includesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `include`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "maxallowed": {
             "description": "Use this value exactly as autorange maximum.",
             "editType": "plot",
@@ -5398,11 +5306,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_yaxes(categoryarray=&lt;VALUE&gt;)"
         },
-        "categoryarraysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "categoryorder": {
           "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`. Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the numerical order of the values. Similarly, the order can be determined by the min, max, sum, mean, geometric mean or median of all the values.",
           "dflt": "trace",
@@ -5768,11 +5671,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_yaxes(minor_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "editType": "ticks",
@@ -6099,7 +5997,7 @@
           "magic_underscores": "fig.update_yaxes(spikedash=&lt;VALUE&gt;)"
         },
         "spikemode": {
-          "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the  series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on",
+          "description": "Determines the drawing mode for the spike line If *toaxis*, the line is drawn from the data point to the axis the series is plotted on. If *across*, the line is drawn across the entire plot area, and supercedes *toaxis*. If *marker*, then a marker dot is drawn on the axis the series is plotted on",
           "dflt": "toaxis",
           "editType": "none",
           "flags": [
@@ -6313,11 +6211,6 @@
           "valType": "integer",
           "magic_underscores": "fig.update_yaxes(ticklabelindex=&lt;VALUE&gt;)"
         },
-        "ticklabelindexsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ticklabelindex`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "ticklabelmode": {
           "description": "Determines where tick labels are drawn with respect to their corresponding ticks and grid lines. Only has an effect for axes of `type` *date* When set to *period*, tick labels are drawn in the middle of the period between ticks.",
           "dflt": "instant",
@@ -6390,7 +6283,7 @@
           "magic_underscores": "fig.update_yaxes(ticklen=&lt;VALUE&gt;)"
         },
         "tickmode": {
-          "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property.",
+          "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided). If *sync*, the number of ticks will sync with the overlayed axis set by `overlaying` property. When no other tick info is provided, overlaying (non-categorical) axes default to *sync*, while other axes default to *auto*.",
           "editType": "ticks",
           "impliedEdits": {
             "magic_underscores": "fig.update_yaxes(tickmode_impliedEdits=&lt;VALUE&gt;)"
@@ -6446,22 +6339,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_yaxes(ticktext=&lt;VALUE&gt;)"
         },
-        "ticktextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "tickvals": {
           "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
           "editType": "ticks",
           "valType": "data_array",
           "magic_underscores": "fig.update_yaxes(tickvals=&lt;VALUE&gt;)"
         },
-        "tickvalssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "tickwidth": {
           "description": "Sets the tick width (in px).",
           "dflt": 1,
@@ -7097,22 +6980,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_ternaries(aaxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_ternaries(aaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -7674,22 +7547,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_ternaries(baxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_ternaries(baxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -8258,22 +8121,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_ternaries(caxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_ternaries(caxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -8402,7 +8255,7 @@
         },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this ternary subplot .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this ternary subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -8412,7 +8265,7 @@
           "editType": "plot",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this ternary subplot .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this ternary subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -9094,7 +8947,7 @@
         },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this scene subplot .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this scene subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -9104,7 +8957,7 @@
           "editType": "plot",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this scene subplot .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this scene subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -9235,7 +9088,7 @@
             "editType": "plot",
             "include": {
               "arrayOk": true,
-              "description": "Ensure this value is included in autorange.",
+              "description": "Extends the autorange to include this value or array of values, even when they fall outside the data range. Has no effect on endpoints set by `autorangeoptions.minallowed` or `autorangeoptions.maxallowed`. Subject to `autorangeoptions.clipmin` and `autorangeoptions.clipmax`.",
               "editType": "plot",
               "impliedEdits": {
                 "magic_underscores": "fig.update_scenes(xaxis_autorangeoptions_include_impliedEdits=&lt;VALUE&gt;)"
@@ -9243,11 +9096,6 @@
               "valType": "any",
               "magic_underscores": "fig.update_scenes(xaxis_autorangeoptions_include=&lt;VALUE&gt;)"
             },
-            "includesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `include`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "maxallowed": {
               "description": "Use this value exactly as autorange maximum.",
               "editType": "plot",
@@ -9318,11 +9166,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(xaxis_categoryarray=&lt;VALUE&gt;)"
           },
-          "categoryarraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "categoryorder": {
             "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`. Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the numerical order of the values. Similarly, the order can be determined by the min, max, sum, mean, geometric mean or median of all the values.",
             "dflt": "trace",
@@ -9856,22 +9699,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(xaxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(xaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -10075,7 +9908,7 @@
             "editType": "plot",
             "include": {
               "arrayOk": true,
-              "description": "Ensure this value is included in autorange.",
+              "description": "Extends the autorange to include this value or array of values, even when they fall outside the data range. Has no effect on endpoints set by `autorangeoptions.minallowed` or `autorangeoptions.maxallowed`. Subject to `autorangeoptions.clipmin` and `autorangeoptions.clipmax`.",
               "editType": "plot",
               "impliedEdits": {
                 "magic_underscores": "fig.update_scenes(yaxis_autorangeoptions_include_impliedEdits=&lt;VALUE&gt;)"
@@ -10083,11 +9916,6 @@
               "valType": "any",
               "magic_underscores": "fig.update_scenes(yaxis_autorangeoptions_include=&lt;VALUE&gt;)"
             },
-            "includesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `include`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "maxallowed": {
               "description": "Use this value exactly as autorange maximum.",
               "editType": "plot",
@@ -10158,11 +9986,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(yaxis_categoryarray=&lt;VALUE&gt;)"
           },
-          "categoryarraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "categoryorder": {
             "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`. Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the numerical order of the values. Similarly, the order can be determined by the min, max, sum, mean, geometric mean or median of all the values.",
             "dflt": "trace",
@@ -10696,22 +10519,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(yaxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(yaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -10915,7 +10728,7 @@
             "editType": "plot",
             "include": {
               "arrayOk": true,
-              "description": "Ensure this value is included in autorange.",
+              "description": "Extends the autorange to include this value or array of values, even when they fall outside the data range. Has no effect on endpoints set by `autorangeoptions.minallowed` or `autorangeoptions.maxallowed`. Subject to `autorangeoptions.clipmin` and `autorangeoptions.clipmax`.",
               "editType": "plot",
               "impliedEdits": {
                 "magic_underscores": "fig.update_scenes(zaxis_autorangeoptions_include_impliedEdits=&lt;VALUE&gt;)"
@@ -10923,11 +10736,6 @@
               "valType": "any",
               "magic_underscores": "fig.update_scenes(zaxis_autorangeoptions_include=&lt;VALUE&gt;)"
             },
-            "includesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `include`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "maxallowed": {
               "description": "Use this value exactly as autorange maximum.",
               "editType": "plot",
@@ -10998,11 +10806,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(zaxis_categoryarray=&lt;VALUE&gt;)"
           },
-          "categoryarraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "categoryorder": {
             "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`. Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the numerical order of the values. Similarly, the order can be determined by the min, max, sum, mean, geometric mean or median of all the values.",
             "dflt": "trace",
@@ -11536,22 +11339,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(zaxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_scenes(zaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -11773,7 +11566,7 @@
         },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this geo subplot . Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this geo subplot. Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -11783,7 +11576,7 @@
           "editType": "plot",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this geo subplot . Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this geo subplot. Note that geo subplots are constrained by domain. In general, when `projection.scale` is set to 1. a map will fit either its x or y domain, but not both.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -11842,8 +11635,8 @@
         },
         "editType": "plot",
         "fitbounds": {
-          "description": "Determines if this subplot's view settings are auto-computed to fit trace data. On scoped maps, setting `fitbounds` leads to `center.lon` and `center.lat` getting auto-filled. On maps with a non-clipped projection, setting `fitbounds` leads to `center.lon`, `center.lat`, and `projection.rotation.lon` getting auto-filled. On maps with a clipped projection, setting `fitbounds` leads to `center.lon`, `center.lat`, `projection.rotation.lon`, `projection.rotation.lat`, `lonaxis.range` and `lataxis.range` getting auto-filled. If *locations*, only the trace's visible locations are considered in the `fitbounds` computations. If *geojson*, the entire trace input `geojson` (if provided) is considered in the `fitbounds` computations, Defaults to *false*.",
-          "dflt": false,
+          "description": "Determines if this subplot's view settings are auto-computed to fit trace data. On scoped maps, setting `fitbounds` leads to `center.lon` and `center.lat` getting auto-filled. On maps with a non-clipped projection, setting `fitbounds` leads to `center.lon`, `center.lat`, and `projection.rotation.lon` getting auto-filled. On maps with a clipped projection, setting `fitbounds` leads to `center.lon`, `center.lat`, `projection.rotation.lon`, `projection.rotation.lat`, `lonaxis.range` and `lataxis.range` getting auto-filled. If *locations* (default), only the trace's visible locations are considered in the `fitbounds` computations. If *geojson*, the entire trace input `geojson` (if provided) is considered in the `fitbounds` computations. If *false*, the view settings are used as-is; set this to opt out of auto-fitting.",
+          "dflt": "locations",
           "editType": "plot",
           "valType": "enumerated",
           "values": [
@@ -12041,6 +11834,22 @@
             "magic_underscores": "fig.update_geos(projection_distance=&lt;VALUE&gt;)"
           },
           "editType": "plot",
+          "maxscale": {
+            "description": "Sets the maximum zoom level of the map view, relative to `projection.scale`. A `maxscale` of *2* (200%) prevents the user from zooming in beyond twice the base zoom level. Must be greater than or equal to *0*; has no upper bound. Defaults to *null* for no upper bound on zoom.",
+            "dflt": null,
+            "editType": "plot",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_geos(projection_maxscale=&lt;VALUE&gt;)"
+          },
+          "minscale": {
+            "description": "Sets the minimum zoom level of the map view, relative to `projection.scale`. A `minscale` of *0.5* (50%) prevents the user from zooming out beyond half the base zoom level. Must be greater than or equal to *0*; has no upper bound. The default of *0* imposes no lower bound on zoom.",
+            "dflt": 0,
+            "editType": "plot",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_geos(projection_minscale=&lt;VALUE&gt;)"
+          },
           "parallels": {
             "description": "For conic projection types only. Sets the parallels (tangent, secant) where the cone intersects the sphere.",
             "editType": "plot",
@@ -12380,7 +12189,7 @@
         },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this map subplot .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this map subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -12390,7 +12199,7 @@
           "editType": "plot",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this map subplot .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this map subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -12448,6 +12257,17 @@
           "magic_underscores": "fig.update_layout(map_domain=dict(...))"
         },
         "editType": "plot",
+        "fitbounds": {
+          "description": "Determines if this subplot's view settings are auto-computed to fit trace data. If *locations* (default), the view is auto-fit to the lon/lat coordinates of the visible trace data. If *false*, the view settings are used as-is; set this to opt out of auto-fitting. If `fitbounds` is enabled but a user provides `center` or `zoom`, auto-fit will be skipped.",
+          "dflt": "locations",
+          "editType": "plot",
+          "valType": "enumerated",
+          "values": [
+            false,
+            "locations"
+          ],
+          "magic_underscores": "fig.update_layout(map_fitbounds=&lt;VALUE&gt;)"
+        },
         "layers": {
           "items": {
             "layer": {
@@ -12494,11 +12314,6 @@
                   "editType": "plot",
                   "valType": "data_array"
                 },
-                "dashsrc": {
-                  "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-                  "editType": "none",
-                  "valType": "string"
-                },
                 "editType": "plot",
                 "role": "object",
                 "width": {
@@ -12737,432 +12552,6 @@
         },
         "magic_underscores": "fig.update_layout(map=dict(...))"
       },
-      "mapbox": {
-        "_arrayAttrRegexps": [
-          {}
-        ],
-        "_isSubplotObj": true,
-        "accesstoken": {
-          "description": "Sets the mapbox access token to be used for this mapbox map. Alternatively, the mapbox access token can be set in the configuration options under `mapboxAccessToken`. Note that accessToken are only required when `style` (e.g with values : basic, streets, outdoors, light, dark, satellite, satellite-streets ) and/or a layout layer references the Mapbox server.",
-          "editType": "plot",
-          "noBlank": true,
-          "strict": true,
-          "valType": "string",
-          "magic_underscores": "fig.update_mapboxes(accesstoken=&lt;VALUE&gt;)"
-        },
-        "bearing": {
-          "description": "Sets the bearing angle of the map in degrees counter-clockwise from North (mapbox.bearing).",
-          "dflt": 0,
-          "editType": "plot",
-          "valType": "number",
-          "magic_underscores": "fig.update_mapboxes(bearing=&lt;VALUE&gt;)"
-        },
-        "bounds": {
-          "east": {
-            "description": "Sets the maximum longitude of the map (in degrees East) if `west`, `south` and `north` are declared.",
-            "editType": "plot",
-            "valType": "number",
-            "magic_underscores": "fig.update_mapboxes(bounds_east=&lt;VALUE&gt;)"
-          },
-          "editType": "plot",
-          "north": {
-            "description": "Sets the maximum latitude of the map (in degrees North) if `east`, `west` and `south` are declared.",
-            "editType": "plot",
-            "valType": "number",
-            "magic_underscores": "fig.update_mapboxes(bounds_north=&lt;VALUE&gt;)"
-          },
-          "role": "object",
-          "south": {
-            "description": "Sets the minimum latitude of the map (in degrees North) if `east`, `west` and `north` are declared.",
-            "editType": "plot",
-            "valType": "number",
-            "magic_underscores": "fig.update_mapboxes(bounds_south=&lt;VALUE&gt;)"
-          },
-          "west": {
-            "description": "Sets the minimum longitude of the map (in degrees East) if `east`, `south` and `north` are declared.",
-            "editType": "plot",
-            "valType": "number",
-            "magic_underscores": "fig.update_mapboxes(bounds_west=&lt;VALUE&gt;)"
-          },
-          "magic_underscores": "fig.update_mapboxes(bounds=dict(...))"
-        },
-        "center": {
-          "editType": "plot",
-          "lat": {
-            "description": "Sets the latitude of the center of the map (in degrees North).",
-            "dflt": 0,
-            "editType": "plot",
-            "valType": "number",
-            "magic_underscores": "fig.update_mapboxes(center_lat=&lt;VALUE&gt;)"
-          },
-          "lon": {
-            "description": "Sets the longitude of the center of the map (in degrees East).",
-            "dflt": 0,
-            "editType": "plot",
-            "valType": "number",
-            "magic_underscores": "fig.update_mapboxes(center_lon=&lt;VALUE&gt;)"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_mapboxes(center=dict(...))"
-        },
-        "domain": {
-          "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this mapbox subplot .",
-            "dflt": 0,
-            "editType": "plot",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_mapboxes(domain_column=&lt;VALUE&gt;)"
-          },
-          "editType": "plot",
-          "role": "object",
-          "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this mapbox subplot .",
-            "dflt": 0,
-            "editType": "plot",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_mapboxes(domain_row=&lt;VALUE&gt;)"
-          },
-          "x": {
-            "description": "Sets the horizontal domain of this mapbox subplot (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
-            "editType": "plot",
-            "items": [
-              {
-                "editType": "plot",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "plot",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_mapboxes(domain_x=list(...))"
-          },
-          "y": {
-            "description": "Sets the vertical domain of this mapbox subplot (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
-            "editType": "plot",
-            "items": [
-              {
-                "editType": "plot",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "plot",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_mapboxes(domain_y=list(...))"
-          },
-          "magic_underscores": "fig.update_mapboxes(domain=dict(...))"
-        },
-        "editType": "plot",
-        "layers": {
-          "items": {
-            "layer": {
-              "below": {
-                "description": "Determines if the layer will be inserted before the layer with the specified ID. If omitted or set to '', the layer will be inserted above every existing layer.",
-                "editType": "plot",
-                "valType": "string"
-              },
-              "circle": {
-                "editType": "plot",
-                "radius": {
-                  "description": "Sets the circle radius (mapbox.layer.paint.circle-radius). Has an effect only when `type` is set to *circle*.",
-                  "dflt": 15,
-                  "editType": "plot",
-                  "valType": "number"
-                },
-                "role": "object"
-              },
-              "color": {
-                "description": "Sets the primary layer color. If `type` is *circle*, color corresponds to the circle color (mapbox.layer.paint.circle-color) If `type` is *line*, color corresponds to the line color (mapbox.layer.paint.line-color) If `type` is *fill*, color corresponds to the fill color (mapbox.layer.paint.fill-color) If `type` is *symbol*, color corresponds to the icon color (mapbox.layer.paint.icon-color)",
-                "dflt": "#444",
-                "editType": "plot",
-                "valType": "color"
-              },
-              "coordinates": {
-                "description": "Sets the coordinates array contains [longitude, latitude] pairs for the image corners listed in clockwise order: top left, top right, bottom right, bottom left. Only has an effect for *image* `sourcetype`.",
-                "editType": "plot",
-                "valType": "any"
-              },
-              "editType": "plot",
-              "fill": {
-                "editType": "plot",
-                "outlinecolor": {
-                  "description": "Sets the fill outline color (mapbox.layer.paint.fill-outline-color). Has an effect only when `type` is set to *fill*.",
-                  "dflt": "#444",
-                  "editType": "plot",
-                  "valType": "color"
-                },
-                "role": "object"
-              },
-              "line": {
-                "dash": {
-                  "description": "Sets the length of dashes and gaps (mapbox.layer.paint.line-dasharray). Has an effect only when `type` is set to *line*.",
-                  "editType": "plot",
-                  "valType": "data_array"
-                },
-                "dashsrc": {
-                  "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-                  "editType": "none",
-                  "valType": "string"
-                },
-                "editType": "plot",
-                "role": "object",
-                "width": {
-                  "description": "Sets the line width (mapbox.layer.paint.line-width). Has an effect only when `type` is set to *line*.",
-                  "dflt": 2,
-                  "editType": "plot",
-                  "valType": "number"
-                }
-              },
-              "maxzoom": {
-                "description": "Sets the maximum zoom level (mapbox.layer.maxzoom). At zoom levels equal to or greater than the maxzoom, the layer will be hidden.",
-                "dflt": 24,
-                "editType": "plot",
-                "max": 24,
-                "min": 0,
-                "valType": "number"
-              },
-              "minzoom": {
-                "description": "Sets the minimum zoom level (mapbox.layer.minzoom). At zoom levels less than the minzoom, the layer will be hidden.",
-                "dflt": 0,
-                "editType": "plot",
-                "max": 24,
-                "min": 0,
-                "valType": "number"
-              },
-              "name": {
-                "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                "editType": "plot",
-                "valType": "string"
-              },
-              "opacity": {
-                "description": "Sets the opacity of the layer. If `type` is *circle*, opacity corresponds to the circle opacity (mapbox.layer.paint.circle-opacity) If `type` is *line*, opacity corresponds to the line opacity (mapbox.layer.paint.line-opacity) If `type` is *fill*, opacity corresponds to the fill opacity (mapbox.layer.paint.fill-opacity) If `type` is *symbol*, opacity corresponds to the icon/text opacity (mapbox.layer.paint.text-opacity)",
-                "dflt": 1,
-                "editType": "plot",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              "role": "object",
-              "source": {
-                "description": "Sets the source data for this layer (mapbox.layer.source). When `sourcetype` is set to *geojson*, `source` can be a URL to a GeoJSON or a GeoJSON object. When `sourcetype` is set to *vector* or *raster*, `source` can be a URL or an array of tile URLs. When `sourcetype` is set to *image*, `source` can be a URL to an image.",
-                "editType": "plot",
-                "valType": "any"
-              },
-              "sourceattribution": {
-                "description": "Sets the attribution for this source.",
-                "editType": "plot",
-                "valType": "string"
-              },
-              "sourcelayer": {
-                "description": "Specifies the layer to use from a vector tile source (mapbox.layer.source-layer). Required for *vector* source type that supports multiple layers.",
-                "dflt": "",
-                "editType": "plot",
-                "valType": "string"
-              },
-              "sourcetype": {
-                "description": "Sets the source type for this layer, that is the type of the layer data.",
-                "dflt": "geojson",
-                "editType": "plot",
-                "valType": "enumerated",
-                "values": [
-                  "geojson",
-                  "vector",
-                  "raster",
-                  "image"
-                ]
-              },
-              "symbol": {
-                "editType": "plot",
-                "icon": {
-                  "description": "Sets the symbol icon image (mapbox.layer.layout.icon-image). Full list: https://www.mapbox.com/maki-icons/",
-                  "dflt": "marker",
-                  "editType": "plot",
-                  "valType": "string"
-                },
-                "iconsize": {
-                  "description": "Sets the symbol icon size (mapbox.layer.layout.icon-size). Has an effect only when `type` is set to *symbol*.",
-                  "dflt": 10,
-                  "editType": "plot",
-                  "valType": "number"
-                },
-                "placement": {
-                  "description": "Sets the symbol and/or text placement (mapbox.layer.layout.symbol-placement). If `placement` is *point*, the label is placed where the geometry is located If `placement` is *line*, the label is placed along the line of the geometry If `placement` is *line-center*, the label is placed on the center of the geometry",
-                  "dflt": "point",
-                  "editType": "plot",
-                  "valType": "enumerated",
-                  "values": [
-                    "point",
-                    "line",
-                    "line-center"
-                  ]
-                },
-                "role": "object",
-                "text": {
-                  "description": "Sets the symbol text (mapbox.layer.layout.text-field).",
-                  "dflt": "",
-                  "editType": "plot",
-                  "valType": "string"
-                },
-                "textfont": {
-                  "color": {
-                    "editType": "plot",
-                    "valType": "color"
-                  },
-                  "description": "Sets the icon text font (color=mapbox.layer.paint.text-color, size=mapbox.layer.layout.text-size). Has an effect only when `type` is set to *symbol*.",
-                  "editType": "plot",
-                  "family": {
-                    "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                    "dflt": "Open Sans Regular, Arial Unicode MS Regular",
-                    "editType": "plot",
-                    "noBlank": true,
-                    "strict": true,
-                    "valType": "string"
-                  },
-                  "role": "object",
-                  "size": {
-                    "editType": "plot",
-                    "min": 1,
-                    "valType": "number"
-                  },
-                  "style": {
-                    "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                    "dflt": "normal",
-                    "editType": "plot",
-                    "valType": "enumerated",
-                    "values": [
-                      "normal",
-                      "italic"
-                    ]
-                  },
-                  "weight": {
-                    "description": "Sets the weight (or boldness) of the font.",
-                    "dflt": "normal",
-                    "editType": "plot",
-                    "extras": [
-                      "normal",
-                      "bold"
-                    ],
-                    "max": 1000,
-                    "min": 1,
-                    "valType": "integer"
-                  }
-                },
-                "textposition": {
-                  "arrayOk": false,
-                  "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
-                  "dflt": "middle center",
-                  "editType": "plot",
-                  "valType": "enumerated",
-                  "values": [
-                    "top left",
-                    "top center",
-                    "top right",
-                    "middle left",
-                    "middle center",
-                    "middle right",
-                    "bottom left",
-                    "bottom center",
-                    "bottom right"
-                  ]
-                }
-              },
-              "templateitemname": {
-                "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                "editType": "plot",
-                "valType": "string"
-              },
-              "type": {
-                "description": "Sets the layer type, that is the how the layer data set in `source` will be rendered With `sourcetype` set to *geojson*, the following values are allowed: *circle*, *line*, *fill* and *symbol*. but note that *line* and *fill* are not compatible with Point GeoJSON geometries. With `sourcetype` set to *vector*, the following values are allowed:  *circle*, *line*, *fill* and *symbol*. With `sourcetype` set to *raster* or *image*, only the *raster* value is allowed.",
-                "dflt": "circle",
-                "editType": "plot",
-                "valType": "enumerated",
-                "values": [
-                  "circle",
-                  "line",
-                  "fill",
-                  "symbol",
-                  "raster"
-                ]
-              },
-              "visible": {
-                "description": "Determines whether this layer is displayed",
-                "dflt": true,
-                "editType": "plot",
-                "valType": "boolean"
-              }
-            }
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_mapboxes(layers=list(...))"
-        },
-        "pitch": {
-          "description": "Sets the pitch angle of the map (in degrees, where *0* means perpendicular to the surface of the map) (mapbox.pitch).",
-          "dflt": 0,
-          "editType": "plot",
-          "valType": "number",
-          "magic_underscores": "fig.update_mapboxes(pitch=&lt;VALUE&gt;)"
-        },
-        "role": "object",
-        "style": {
-          "description": "Defines the map layers that are rendered by default below the trace layers defined in `data`, which are themselves by default rendered below the layers defined in `layout.mapbox.layers`.  These layers can be defined either explicitly as a Mapbox Style object which can contain multiple layer definitions that load data from any public or private Tile Map Service (TMS or XYZ) or Web Map Service (WMS) or implicitly by using one of the built-in style objects which use WMSes which do not require any access tokens, or by using a default Mapbox style or custom Mapbox style URL, both of which require a Mapbox access token  Note that Mapbox access token can be set in the `accesstoken` attribute or in the `mapboxAccessToken` config option.  Mapbox Style objects are of the form described in the Mapbox GL JS documentation available at https://docs.mapbox.com/mapbox-gl-js/style-spec  The built-in plotly.js styles objects are: carto-darkmatter, carto-positron, open-street-map, stamen-terrain, stamen-toner, stamen-watercolor, white-bg  The built-in Mapbox styles are: basic, streets, outdoors, light, dark, satellite, satellite-streets  Mapbox style URLs are of the form: mapbox://mapbox.mapbox-<name>-<version>",
-          "dflt": "basic",
-          "editType": "plot",
-          "valType": "any",
-          "values": [
-            "basic",
-            "streets",
-            "outdoors",
-            "light",
-            "dark",
-            "satellite",
-            "satellite-streets",
-            "carto-darkmatter",
-            "carto-positron",
-            "open-street-map",
-            "stamen-terrain",
-            "stamen-toner",
-            "stamen-watercolor",
-            "white-bg"
-          ],
-          "magic_underscores": "fig.update_mapboxes(style=&lt;VALUE&gt;)"
-        },
-        "uirevision": {
-          "description": "Controls persistence of user-driven changes in the view: `center`, `zoom`, `bearing`, `pitch`. Defaults to `layout.uirevision`.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_mapboxes(uirevision=&lt;VALUE&gt;)"
-        },
-        "zoom": {
-          "description": "Sets the zoom level of the map (mapbox.zoom).",
-          "dflt": 1,
-          "editType": "plot",
-          "valType": "number",
-          "magic_underscores": "fig.update_mapboxes(zoom=&lt;VALUE&gt;)"
-        },
-        "magic_underscores": "fig.update_mapboxes(...)"
-      },
       "polar": {
         "_isSubplotObj": true,
         "angularaxis": {
@@ -13183,11 +12572,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_polars(angularaxis_categoryarray=&lt;VALUE&gt;)"
           },
-          "categoryarraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "categoryorder": {
             "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`. Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the numerical order of the values. Similarly, the order can be determined by the min, max, sum, mean, geometric mean or median of all the values.",
             "dflt": "trace",
@@ -13688,22 +13072,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_polars(angularaxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_polars(angularaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -13749,7 +13123,7 @@
         },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this polar subplot .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this polar subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -13759,7 +13133,7 @@
           "editType": "plot",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this polar subplot .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this polar subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -13885,7 +13259,7 @@
             "editType": "plot",
             "include": {
               "arrayOk": true,
-              "description": "Ensure this value is included in autorange.",
+              "description": "Extends the autorange to include this value or array of values, even when they fall outside the data range. Has no effect on endpoints set by `autorangeoptions.minallowed` or `autorangeoptions.maxallowed`. Subject to `autorangeoptions.clipmin` and `autorangeoptions.clipmax`.",
               "editType": "plot",
               "impliedEdits": {
                 "magic_underscores": "fig.update_polars(radialaxis_autorangeoptions_include_impliedEdits=&lt;VALUE&gt;)"
@@ -13893,11 +13267,6 @@
               "valType": "any",
               "magic_underscores": "fig.update_polars(radialaxis_autorangeoptions_include=&lt;VALUE&gt;)"
             },
-            "includesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `include`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "maxallowed": {
               "description": "Use this value exactly as autorange maximum.",
               "editType": "plot",
@@ -13976,11 +13345,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_polars(radialaxis_categoryarray=&lt;VALUE&gt;)"
           },
-          "categoryarraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "categoryorder": {
             "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`. Set `categoryorder` to *total ascending* or *total descending* if order should be determined by the numerical order of the values. Similarly, the order can be determined by the min, max, sum, mean, geometric mean or median of all the values.",
             "dflt": "trace",
@@ -14515,22 +13879,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_polars(radialaxis_ticktext=&lt;VALUE&gt;)"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "plot",
             "valType": "data_array",
             "magic_underscores": "fig.update_polars(radialaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -14720,7 +14074,7 @@
         },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this smith subplot .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this smith subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -14730,7 +14084,7 @@
           "editType": "plot",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this smith subplot .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this smith subplot.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -15067,11 +14421,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_smiths(imaginaryaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 2,
@@ -15393,11 +14742,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_smiths(realaxis_tickvals=&lt;VALUE&gt;)"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 2,
@@ -15484,7 +14828,7 @@
               "magic_underscores": "fig.update_annotations(ax=&lt;VALUE&gt;)"
             },
             "axref": {
-              "description": "Indicates in what coordinates the tail of the annotation (ax,ay) is specified. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x  axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis. In order for absolute positioning of the arrow to work, *axref* must be exactly the same as *xref*, otherwise *axref* will revert to *pixel* (explained next). For relative positioning, *axref* can be set to *pixel*, in which case the *ax* value is specified in pixels relative to *x*. Absolute positioning is useful for trendline annotations which should continue to indicate the correct trend when zoomed. Relative positioning is useful for specifying the text offset for an annotated point.",
+              "description": "Indicates in what coordinates the tail of the annotation (ax,ay) is specified. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis. In order for absolute positioning of the arrow to work, *axref* must be exactly the same as *xref*, otherwise *axref* will revert to *pixel* (explained next). For relative positioning, *axref* can be set to *pixel*, in which case the *ax* value is specified in pixels relative to *x*. Absolute positioning is useful for trendline annotations which should continue to indicate the correct trend when zoomed. Relative positioning is useful for specifying the text offset for an annotated point.",
               "dflt": "pixel",
               "editType": "calc",
               "valType": "enumerated",
@@ -15501,7 +14845,7 @@
               "magic_underscores": "fig.update_annotations(ay=&lt;VALUE&gt;)"
             },
             "ayref": {
-              "description": "Indicates in what coordinates the tail of the annotation (ax,ay) is specified. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y  axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis. In order for absolute positioning of the arrow to work, *ayref* must be exactly the same as *yref*, otherwise *ayref* will revert to *pixel* (explained next). For relative positioning, *ayref* can be set to *pixel*, in which case the *ay* value is specified in pixels relative to *y*. Absolute positioning is useful for trendline annotations which should continue to indicate the correct trend when zoomed. Relative positioning is useful for specifying the text offset for an annotated point.",
+              "description": "Indicates in what coordinates the tail of the annotation (ax,ay) is specified. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis. In order for absolute positioning of the arrow to work, *ayref* must be exactly the same as *yref*, otherwise *ayref* will revert to *pixel* (explained next). For relative positioning, *ayref* can be set to *pixel*, in which case the *ay* value is specified in pixels relative to *y*. Absolute positioning is useful for trendline annotations which should continue to indicate the correct trend when zoomed. Relative positioning is useful for specifying the text offset for an annotated point.",
               "dflt": "pixel",
               "editType": "calc",
               "valType": "enumerated",
@@ -15917,7 +15261,7 @@
               "magic_underscores": "fig.update_annotations(xclick=&lt;VALUE&gt;)"
             },
             "xref": {
-              "description": "Sets the annotation's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x  axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis.",
+              "description": "Sets the annotation's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis.",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
@@ -15959,7 +15303,7 @@
               "magic_underscores": "fig.update_annotations(yclick=&lt;VALUE&gt;)"
             },
             "yref": {
-              "description": "Sets the annotation's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y  axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis.",
+              "description": "Sets the annotation's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis.",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
@@ -16478,7 +15822,7 @@
             },
             "xref": {
               "arrayOk": true,
-              "description": "Sets the shape's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x  axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis. If an array of axis IDs is provided, each `x` value will refer to the corresponding axis, e.g., ['x', 'x2'] for a rectangle, line, or circle means `x0` uses the `x` axis and `x1` uses the `x2` axis. Path shapes using an array should have one entry for each x coordinate in the string.",
+              "description": "Sets the shape's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis. If an array of axis IDs is provided, each `x` value will refer to the corresponding axis, e.g., ['x', 'x2'] for a rectangle, line, or circle means `x0` uses the `x` axis and `x1` uses the `x2` axis. Path shapes using an array should have one entry for each x coordinate in the string.",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
@@ -16487,11 +15831,6 @@
               ],
               "magic_underscores": "fig.update_shapes(xref=&lt;VALUE&gt;)"
             },
-            "xrefsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `xref`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "xsizemode": {
               "description": "Sets the shapes's sizing mode along the x axis. If set to *scaled*, `x0`, `x1` and x coordinates within `path` refer to data values on the x axis or a fraction of the plot area's width (`xref` set to *paper*). If set to *pixel*, `xanchor` specifies the x position in terms of data or plot fraction but `x0`, `x1` and x coordinates within `path` are pixels relative to `xanchor`. This way, the shape can have a fixed width while maintaining a position relative to data or plot fraction. Note: `xsizemode` *pixel* is not supported when `xref` is an array.",
               "dflt": "scaled",
@@ -16541,7 +15880,7 @@
             },
             "yref": {
               "arrayOk": true,
-              "description": "Sets the shape's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y  axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis. If an array of axis IDs is provided, each `y` value will refer to the corresponding axis, e.g., ['y', 'y2'] for a rectangle, line, or circle means `y0` uses the `y` axis and `y1` uses the `y2` axis. Path shapes using an array should have one entry for each y coordinate in the string.",
+              "description": "Sets the shape's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis. If an array of axis IDs is provided, each `y` value will refer to the corresponding axis, e.g., ['y', 'y2'] for a rectangle, line, or circle means `y0` uses the `y` axis and `y1` uses the `y2` axis. Path shapes using an array should have one entry for each y coordinate in the string.",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
@@ -16550,11 +15889,6 @@
               ],
               "magic_underscores": "fig.update_shapes(yref=&lt;VALUE&gt;)"
             },
-            "yrefsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `yref`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "ysizemode": {
               "description": "Sets the shapes's sizing mode along the y axis. If set to *scaled*, `y0`, `y1` and y coordinates within `path` refer to data values on the y axis or a fraction of the plot area's height (`yref` set to *paper*). If set to *pixel*, `yanchor` specifies the y position in terms of data or plot fraction but `y0`, `y1` and y coordinates within `path` are pixels relative to `yanchor`. This way, the shape can have a fixed height while maintaining a position relative to data or plot fraction. Note: `ysizemode` *pixel* is not supported when `yref` is an array.",
               "dflt": "scaled",
@@ -17128,7 +16462,7 @@
               "magic_underscores": "fig.update_layout_images(xanchor=&lt;VALUE&gt;)"
             },
             "xref": {
-              "description": "Sets the images's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x  axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis.",
+              "description": "Sets the images's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis.",
               "dflt": "paper",
               "editType": "arraydraw",
               "valType": "enumerated",
@@ -17158,7 +16492,7 @@
               "magic_underscores": "fig.update_layout_images(yanchor=&lt;VALUE&gt;)"
             },
             "yref": {
-              "description": "Sets the images's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y  axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis.",
+              "description": "Sets the images's y coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis.",
               "dflt": "paper",
               "editType": "arraydraw",
               "valType": "enumerated",
@@ -18097,7 +17431,7 @@
               "valType": "any"
             },
             "xref": {
-              "description": "Sets the selection's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x  axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis.",
+              "description": "Sets the selection's x coordinate axis. If set to a x axis id (e.g. *x* or *x2*), the `x` position refers to a x coordinate. If set to *paper*, the `x` position refers to the distance from the left of the plotting area in normalized coordinates where *0* (*1*) corresponds to the left (right). If set to a x axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the left of the domain of that axis: e.g., *x2 domain* refers to the domain of the second x axis and a x position of 0.5 refers to the point between the left and the right of the domain of the second x axis.",
               "editType": "arraydraw",
               "valType": "enumerated",
               "values": [
@@ -18116,7 +17450,7 @@
               "valType": "any"
             },
             "yref": {
-              "description": "Sets the selection's x coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y  axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis.",
+              "description": "Sets the selection's x coordinate axis. If set to a y axis id (e.g. *y* or *y2*), the `y` position refers to a y coordinate. If set to *paper*, the `y` position refers to the distance from the bottom of the plotting area in normalized coordinates where *0* (*1*) corresponds to the bottom (top). If set to a y axis ID followed by *domain* (separated by a space), the position behaves like for *paper*, but refers to the distance in fractions of the domain length from the bottom of the domain of that axis: e.g., *y2 domain* refers to the domain of the second y axis and a y position of 0.5 refers to the point between the bottom and the top of the domain of the second y axis.",
               "editType": "arraydraw",
               "valType": "enumerated",
               "values": [
@@ -18129,13 +17463,6 @@
         "role": "object",
         "magic_underscores": "fig.update_layout(selections=list(...))"
       },
-      "hidesources": {
-        "description": "Determines whether or not a text link citing the data source is placed at the bottom-right cored of the figure. Has only an effect only on graphs that have been generated via forked graphs from the Chart Studio Cloud (at https://chart-studio.plotly.com or on-premise).",
-        "dflt": false,
-        "editType": "plot",
-        "valType": "boolean",
-        "magic_underscores": "fig.update_layout(hidesources=&lt;VALUE&gt;)"
-      },
       "editType": "calc",
       "magic_underscores": "fig.update_layout(...)"
     }
@@ -18346,11 +17673,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -18365,11 +17687,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "x0": {
           "anim": true,
           "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
@@ -18393,11 +17710,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "y0": {
           "anim": true,
           "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
@@ -18422,11 +17734,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
@@ -18446,11 +17753,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. ",
@@ -18466,11 +17768,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -18479,14 +17776,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -18504,11 +17796,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -18524,20 +17811,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
           "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
@@ -18550,22 +17832,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -18695,11 +17967,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_angleref=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -19228,22 +18495,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -19355,7 +18612,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -19448,7 +18705,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scatter'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -19458,11 +18715,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "gradient": {
             "color": {
@@ -19472,11 +18724,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_gradient_color=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "type": {
@@ -19493,11 +18740,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_gradient_type=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "typesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `type`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_gradient=dict(...), selector=dict(type='scatter'))"
           },
           "line": {
@@ -19570,7 +18812,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -19580,11 +18822,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "dash": {
               "arrayOk": true,
               "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
@@ -19601,11 +18838,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "dashsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -19624,11 +18856,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scatter'))"
           },
           "maxdisplayed": {
@@ -19649,11 +18876,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -19705,11 +18927,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "standoff": {
             "anim": true,
             "arrayOk": true,
@@ -19720,11 +18937,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_standoff=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "standoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `standoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -20221,11 +19433,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scatter'))"
         },
         "line": {
@@ -20238,11 +19445,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(line_backoff=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "backoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `backoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "anim": true,
             "description": "Sets the line color.",
@@ -20316,11 +19518,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the text font.",
           "editType": "calc",
           "family": {
@@ -20332,11 +19529,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -20353,11 +19545,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -20367,11 +19554,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -20379,11 +19561,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -20396,11 +19573,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -20415,11 +19587,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -20436,11 +19603,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -20455,11 +19617,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scatter'))"
         },
         "error_x": {
@@ -20475,16 +19632,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(error_x_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the stroke color of the error bars.",
             "editType": "style",
@@ -20582,16 +19729,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(error_y_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the stroke color of the error bars.",
             "editType": "style",
@@ -20842,11 +19979,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(fillpattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the pattern within the marker.",
           "editType": "style",
           "fgcolor": {
@@ -20856,11 +19988,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(fillpattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "fgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "fgopacity": {
             "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
             "editType": "style",
@@ -20887,11 +20014,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(fillpattern_path=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "pathsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shape": {
             "arrayOk": true,
@@ -20911,11 +20033,6 @@
             ],
             "magic_underscores": "fig.update_traces(fillpattern_shape=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "shapesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
@@ -20925,11 +20042,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(fillpattern_size=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "solidity": {
             "arrayOk": true,
             "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
@@ -20940,11 +20052,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(fillpattern_solidity=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "soliditysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(fillpattern=dict(...), selector=dict(type='scatter'))"
         },
         "hoverlabel": {
@@ -20961,11 +20068,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -20973,11 +20075,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -20985,11 +20082,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -20998,11 +20090,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -21014,11 +20101,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -21035,11 +20117,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -21049,11 +20126,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -21061,11 +20133,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -21078,11 +20145,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -21097,11 +20159,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -21118,11 +20175,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -21137,11 +20189,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scatter'))"
           },
           "namelength": {
@@ -21153,11 +20200,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scatter'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -21245,28 +20287,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scatter'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scatter'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scatter'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scatter'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='scatter'))"
       },
       "categories": [
@@ -21505,22 +20525,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "x": {
           "description": "Sets the x coordinates.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "x0": {
           "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
           "dflt": 0,
@@ -21541,11 +20551,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "y0": {
           "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
           "dflt": 0,
@@ -21568,11 +20573,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
@@ -21592,11 +20592,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. ",
@@ -21612,11 +20607,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -21625,14 +20615,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -21650,11 +20635,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -21670,20 +20650,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
           "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
@@ -21696,22 +20671,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -21785,11 +20750,6 @@
             "valType": "angle",
             "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -22317,22 +21277,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "calc",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -22444,7 +21394,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "calc",
                 "valType": "enumerated",
                 "values": [
@@ -22537,7 +21487,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattergl'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -22547,11 +21497,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "line": {
             "autocolorscale": {
@@ -22622,7 +21567,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -22632,11 +21577,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -22654,11 +21594,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scattergl'))"
           },
           "opacity": {
@@ -22670,11 +21605,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -22725,11 +21655,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -23226,11 +22151,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattergl'))"
         },
         "line": {
@@ -23288,11 +22208,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the text font.",
           "editType": "calc",
           "family": {
@@ -23304,11 +22219,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "size": {
             "arrayOk": true,
@@ -23317,11 +22227,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -23334,11 +22239,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -23351,11 +22251,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -23368,11 +22263,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattergl'))"
         },
         "error_x": {
@@ -23388,16 +22278,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(error_x_arrayminus=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the stroke color of the error bars.",
             "editType": "calc",
@@ -23495,16 +22375,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(error_y_arrayminus=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the stroke color of the error bars.",
             "editType": "calc",
@@ -23717,11 +22587,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -23729,11 +22594,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -23741,11 +22601,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -23754,11 +22609,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -23770,11 +22620,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -23791,11 +22636,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -23805,11 +22645,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -23817,11 +22652,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -23834,11 +22664,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -23853,11 +22678,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -23874,11 +22694,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -23893,11 +22708,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattergl'))"
           },
           "namelength": {
@@ -23909,11 +22719,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -23980,28 +22785,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scattergl'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scattergl'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='scattergl'))"
       },
       "categories": [
@@ -24210,11 +22993,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -24229,11 +23007,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "x0": {
           "anim": true,
           "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
@@ -24257,11 +23030,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "y0": {
           "anim": true,
           "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
@@ -24286,11 +23054,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(base=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "basesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `base`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "width": {
           "arrayOk": true,
           "description": "Sets the bar width (in position axis units).",
@@ -24300,11 +23063,6 @@
           "valType": "number",
           "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "widthsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "offset": {
           "arrayOk": true,
           "description": "Shifts the position where the bar is drawn (in position axis units). In *group* barmode, traces that set *offset* will be excluded and drawn in *overlay* mode instead.",
@@ -24313,11 +23071,6 @@
           "valType": "number",
           "magic_underscores": "fig.update_traces(offset=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "offsetsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `offset`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "arrayOk": true,
           "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
@@ -24326,11 +23079,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed), unless there is another bar stacked on this one, then the text gets pushed inside. *auto* tries to position `text` inside the bar, but if the bar is too small and no bar is stacked on this one the text is moved outside. If *none*, no text appears.",
@@ -24345,11 +23093,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `value` and `label`.",
@@ -24365,11 +23108,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -24378,14 +23116,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -24403,11 +23136,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `value` and `label`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -24423,20 +23151,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
           "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
@@ -24449,22 +23172,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -25081,22 +23794,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -25208,7 +23911,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -25301,7 +24004,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='bar'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -25311,11 +24014,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "cornerradius": {
             "description": "Sets the rounding of corners. May be an integer number of pixels, or a percentage of bar width (as a string ending in %). Defaults to `layout.barcornerradius`. In stack or relative barmode, the first trace to set cornerradius is used for the whole stack.",
             "editType": "calc",
@@ -25392,7 +24090,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -25402,11 +24100,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -25426,11 +24119,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='bar'))"
           },
           "opacity": {
@@ -25443,11 +24131,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "pattern": {
             "bgcolor": {
               "arrayOk": true,
@@ -25456,11 +24139,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the pattern within the marker.",
             "editType": "style",
             "fgcolor": {
@@ -25470,11 +24148,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "fgopacity": {
               "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
               "editType": "style",
@@ -25501,11 +24174,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shape": {
               "arrayOk": true,
@@ -25525,11 +24193,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
@@ -25539,11 +24202,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "solidity": {
               "arrayOk": true,
               "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
@@ -25554,11 +24212,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='bar'))"
           },
           "reversescale": {
@@ -25592,11 +24245,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `text`.",
           "editType": "calc",
           "family": {
@@ -25608,11 +24256,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -25629,11 +24272,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -25643,11 +24281,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -25655,11 +24288,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -25672,11 +24300,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -25691,11 +24314,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -25712,11 +24330,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -25731,11 +24344,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='bar'))"
         },
         "error_x": {
@@ -25751,16 +24359,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(error_x_arrayminus=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the stroke color of the error bars.",
             "editType": "style",
@@ -25858,16 +24456,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(error_y_arrayminus=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the stroke color of the error bars.",
             "editType": "style",
@@ -26057,11 +24645,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -26069,11 +24652,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -26081,11 +24659,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -26094,11 +24667,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -26110,11 +24678,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -26131,11 +24694,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -26145,11 +24703,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -26157,11 +24710,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -26174,11 +24722,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -26193,11 +24736,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -26214,11 +24752,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -26233,11 +24766,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='bar'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='bar'))"
           },
           "namelength": {
@@ -26249,11 +24777,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -26283,11 +24806,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `text` lying inside the bar.",
           "editType": "calc",
           "family": {
@@ -26299,11 +24817,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -26320,11 +24833,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -26334,11 +24842,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -26346,11 +24849,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -26363,11 +24861,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -26382,11 +24875,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -26403,11 +24891,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -26422,11 +24905,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='bar'))"
         },
         "outsidetextfont": {
@@ -26436,11 +24914,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `text` lying outside the bar.",
           "editType": "calc",
           "family": {
@@ -26452,11 +24925,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -26473,11 +24941,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -26487,11 +24950,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -26499,11 +24957,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -26516,11 +24969,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -26535,11 +24983,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -26556,11 +24999,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -26575,11 +25013,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='bar'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='bar'))"
         },
         "xcalendar": {
@@ -26638,28 +25071,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='bar'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='bar'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='bar'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='bar'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='bar'))"
       },
       "categories": [
@@ -26747,11 +25158,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(title_font_color=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used for `title`.",
             "editType": "plot",
             "family": {
@@ -26763,11 +25169,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(title_font_family=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -26784,11 +25185,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -26798,11 +25194,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(title_font_shadow=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "plot",
@@ -26810,11 +25201,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(title_font_size=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -26827,11 +25213,6 @@
               ],
               "magic_underscores": "fig.update_traces(title_font_style=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -26846,11 +25227,6 @@
               ],
               "magic_underscores": "fig.update_traces(title_font_textcase=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -26867,11 +25243,6 @@
               ],
               "magic_underscores": "fig.update_traces(title_font_variant=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -26886,11 +25257,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(title_font_weight=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(title_font=dict(...), selector=dict(type='pie'))"
           },
           "position": {
@@ -26938,11 +25304,6 @@
           "valType": "boolean",
           "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "showlegendsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `showlegend`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "legend": {
           "arrayOk": true,
           "description": "Sets the reference to a legend to show the pie slices in. Can be an array if `values` is set. In that case, each entry specifies the legend reference for one slice. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
@@ -26951,11 +25312,6 @@
           "valType": "subplotid",
           "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "legendsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `legend`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "legendrank": {
           "arrayOk": true,
           "description": "Sets the legend rank for this pie. If passed as an array, this will set the legend rank of the individual pie slices. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
@@ -26964,11 +25320,6 @@
           "valType": "number",
           "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "legendranksrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `legendrank`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
@@ -27109,33 +25460,18 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "values": {
           "description": "Sets the values of the sectors. If omitted, we count occurrences of each label.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(values=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "valuessrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "labels": {
           "description": "Sets the sector labels. If `labels` entries are duplicated, we sum associated `values` or simply count occurrences if `values` is not provided. For other array attributes (including color) we use the first non-empty entry among all occurrences of the label.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(labels=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "labelssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `labels`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "dlabel": {
           "description": "Sets the label step. See `label0` for more info.",
           "dflt": 1,
@@ -27160,22 +25496,12 @@
           "valType": "number",
           "magic_underscores": "fig.update_traces(pull=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "pullsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `pull`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will be seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "editType": "plot",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Specifies the location of the `textinfo`.",
@@ -27190,11 +25516,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label`, `color`, `value`, `percent` and `text`.",
@@ -27210,11 +25531,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -27223,14 +25539,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. Flags are rendered in a fixed order; use `hovertemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -27248,11 +25559,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label`, `color`, `value`, `percent` and `text`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -27268,11 +25574,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -27280,25 +25581,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this pie trace .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this pie trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -27308,7 +25599,7 @@
           "editType": "calc",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this pie trace .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this pie trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -27379,11 +25670,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(marker_colors=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "colorssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `colors`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "line": {
             "color": {
@@ -27394,11 +25680,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "width": {
@@ -27410,11 +25691,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='pie'))"
           },
           "pattern": {
@@ -27425,11 +25701,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the pattern within the marker.",
             "editType": "style",
             "fgcolor": {
@@ -27439,11 +25710,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "fgopacity": {
               "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
               "editType": "style",
@@ -27470,11 +25736,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shape": {
               "arrayOk": true,
@@ -27494,11 +25755,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
@@ -27508,11 +25764,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "solidity": {
               "arrayOk": true,
               "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
@@ -27523,11 +25774,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='pie'))"
           },
           "role": "object",
@@ -27540,11 +25786,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo`.",
           "editType": "plot",
           "family": {
@@ -27556,11 +25797,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -27577,11 +25813,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -27591,11 +25822,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -27603,11 +25829,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -27620,11 +25841,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -27639,11 +25855,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -27660,11 +25871,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -27679,15 +25885,10 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='pie'))"
         },
         "textinfo": {
-          "description": "Determines which trace information appear on the graph.",
+          "description": "Determines what trace information appears on the graph. Flags are rendered in a fixed order; use `texttemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "editType": "calc",
           "extras": [
             "none"
@@ -27735,11 +25936,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -27747,11 +25943,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -27759,11 +25950,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -27772,11 +25958,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -27788,11 +25969,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -27809,11 +25985,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -27823,11 +25994,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -27835,11 +26001,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -27852,11 +26013,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -27871,11 +26027,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -27892,11 +26043,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -27911,11 +26057,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='pie'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='pie'))"
           },
           "namelength": {
@@ -27927,11 +26068,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -27949,11 +26085,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying inside the sector.",
           "editType": "plot",
           "family": {
@@ -27965,11 +26096,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -27986,11 +26112,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -28000,11 +26121,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -28012,11 +26128,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -28029,11 +26140,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -28048,11 +26154,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -28069,11 +26170,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -28088,11 +26184,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='pie'))"
         },
         "insidetextorientation": {
@@ -28115,11 +26206,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying outside the sector.",
           "editType": "plot",
           "family": {
@@ -28131,11 +26217,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -28152,11 +26233,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -28166,11 +26242,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -28178,11 +26249,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -28195,11 +26261,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -28214,11 +26275,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -28235,11 +26291,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -28254,11 +26305,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='pie'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='pie'))"
         },
         "rotation": {
@@ -28288,28 +26334,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='pie'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='pie'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='pie'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='pie'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='pie'))"
       },
       "categories": [
@@ -28329,11 +26353,6 @@
           "editType": "calc",
           "valType": "data_array"
         },
-        "hiddenlabelssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hiddenlabels`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "piecolorway": {
           "description": "Sets the default pie slice colors. Defaults to the main `colorway` used for trace colors. If you specify a new list here it can still be extended with lighter and darker colors, see `extendpiecolors`.",
           "editType": "calc",
@@ -28534,11 +26553,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -28556,11 +26570,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "x0": {
           "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
           "dflt": 0,
@@ -28611,11 +26620,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "y0": {
           "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
           "dflt": 0,
@@ -28662,22 +26666,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "description": "Sets the text elements associated with each z value.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `x`, `y`, `z` and `text`.",
           "dflt": "",
@@ -28698,14 +26692,9 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -28723,11 +26712,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -28743,20 +26727,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
           "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
@@ -28769,22 +26748,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -29442,22 +27411,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "colorbars",
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -29569,7 +27528,7 @@
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
@@ -29672,7 +27631,7 @@
           "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
@@ -29707,7 +27666,7 @@
           "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
         "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
@@ -29777,11 +27736,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -29789,11 +27743,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -29801,11 +27750,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -29814,11 +27758,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -29830,11 +27769,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -29851,11 +27785,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -29865,11 +27794,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -29877,11 +27801,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -29894,11 +27813,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -29913,11 +27827,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -29934,11 +27843,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -29953,11 +27857,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='heatmap'))"
           },
           "namelength": {
@@ -29969,11 +27868,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -30054,28 +27948,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='heatmap'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='heatmap'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='heatmap'))"
       },
       "categories": [
@@ -30264,11 +28136,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -30310,11 +28177,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "source": {
           "description": "Specifies the data URI of the image to be visualized. The URI consists of \"data:image/[<media subtype\\\\>][;base64\\\\],<data\\\\>\"",
           "editType": "calc",
@@ -30327,25 +28189,15 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "description": "Same as `text`.",
           "editType": "plot",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "x+y+z+text+name",
           "editType": "none",
           "extras": [
@@ -30364,11 +28216,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `z`, `color` and `colormodel`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -30384,11 +28231,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -30396,22 +28238,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -30512,11 +28344,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='image'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -30524,11 +28351,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='image'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -30536,11 +28358,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='image'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -30549,11 +28366,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -30565,11 +28377,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -30586,11 +28393,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -30600,11 +28402,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -30612,11 +28409,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -30629,11 +28421,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -30648,11 +28435,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -30669,11 +28451,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -30688,11 +28465,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='image'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='image'))"
           },
           "namelength": {
@@ -30704,11 +28476,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='image'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -30725,28 +28492,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='image'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='image'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='image'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='image'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='image'))"
       },
       "categories": [
@@ -30949,11 +28694,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -30971,11 +28711,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "x0": {
           "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
           "dflt": 0,
@@ -31018,11 +28753,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "y0": {
           "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
           "dflt": 0,
@@ -31061,22 +28791,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "description": "Sets the text elements associated with each z value.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "description": "For this trace it only has an effect if `coloring` is set to *heatmap*. Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `x`, `y`, `z` and `text`.",
           "dflt": "",
@@ -31097,14 +28817,9 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -31122,11 +28837,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -31142,20 +28852,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
           "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
@@ -31168,22 +28873,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -31875,22 +29570,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='contour'))"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "colorbars",
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='contour'))"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -32002,7 +29687,7 @@
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
@@ -32105,7 +29790,7 @@
           "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
@@ -32140,7 +29825,7 @@
           "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
         "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
@@ -32332,7 +30017,7 @@
             "magic_underscores": "fig.update_traces(contours_labelformat=&lt;VALUE&gt;, selector=dict(type='contour'))"
           },
           "operation": {
-            "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms.",
+            "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed.",
             "dflt": "=",
             "editType": "calc",
             "valType": "enumerated",
@@ -32431,11 +30116,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='contour'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -32443,11 +30123,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='contour'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -32455,11 +30130,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='contour'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -32468,11 +30138,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -32484,11 +30149,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -32505,11 +30165,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -32519,11 +30174,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -32531,11 +30181,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -32548,11 +30193,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -32567,11 +30207,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -32588,11 +30223,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -32607,11 +30237,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='contour'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='contour'))"
           },
           "namelength": {
@@ -32623,11 +30248,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='contour'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -32716,28 +30336,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='contour'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='contour'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='contour'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='contour'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='contour'))"
       },
       "categories": [
@@ -32752,21 +30350,22 @@
       },
       "type": "contour"
     },
-    "table": {
-      "animatable": false,
+    "quiver": {
+      "animatable": true,
       "attributes": {
-        "type": "table",
+        "type": "quiver",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "uid": {
+          "anim": true,
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -32778,21 +30377,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -32800,7 +30413,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -32810,7 +30423,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -32825,7 +30438,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "role": "object",
             "shadow": {
@@ -32833,13 +30446,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -32850,7 +30463,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -32863,7 +30476,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -32878,7 +30491,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -32891,9 +30504,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='table'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='quiver'))"
           },
           "role": "object",
           "text": {
@@ -32901,55 +30514,123 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='quiver'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "ids": {
+          "anim": true,
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+        "x": {
+          "anim": true,
+          "description": "Sets the x coordinates of the arrow locations.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "columnorder": {
-          "description": "Specifies the rendered order of the data columns; for example, a value `2` at position `0` means that column index `0` in the data will be rendered as the third column, as columns have an index base of zero.",
+        "x0": {
+          "anim": true,
+          "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
+          "dflt": 0,
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "dx": {
+          "anim": true,
+          "description": "Sets the x coordinate step. See `x0` for more info.",
+          "dflt": 1,
           "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(dx=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "y": {
+          "anim": true,
+          "description": "Sets the y coordinates of the arrow locations.",
+          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(columnorder=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "columnordersrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `columnorder`.",
-          "editType": "none",
-          "valType": "string"
+        "y0": {
+          "anim": true,
+          "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
+          "dflt": 0,
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "columnwidth": {
-          "arrayOk": true,
-          "description": "The width of columns expressed as a ratio. Columns fill the available width in proportion of their specified column widths.",
-          "dflt": null,
+        "dy": {
+          "anim": true,
+          "description": "Sets the y coordinate step. See `y0` for more info.",
+          "dflt": 1,
           "editType": "calc",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(columnwidth=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(dy=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "columnwidthsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `columnwidth`.",
-          "editType": "none",
-          "valType": "string"
+        "u": {
+          "anim": true,
+          "description": "Sets the x components of the arrow vectors.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(u=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "v": {
+          "anim": true,
+          "description": "Sets the y components of the arrow vectors.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(v=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "text": {
+          "arrayOk": true,
+          "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "textposition": {
+          "arrayOk": true,
+          "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
+          "dflt": "middle center",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "top left",
+            "top center",
+            "top right",
+            "middle left",
+            "middle center",
+            "middle right",
+            "bottom left",
+            "bottom center",
+            "bottom right"
+          ],
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -32960,669 +30641,1082 @@
           "flags": [
             "x",
             "y",
-            "z",
+            "u",
+            "v",
             "text",
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `x`, `y`, `u`, `v`, `text` and `name`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
           "editType": "none",
-          "valType": "string"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "uhoverformat": {
+          "description": "Sets the hover text formatting rule for `u` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uhoverformat=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "vhoverformat": {
+          "description": "Sets the hover text formatting rule for `v` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(vhoverformat=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='table'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+        "xaxis": {
+          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
+          "dflt": "x",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "domain": {
-          "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this table trace .",
-            "dflt": 0,
+        "yaxis": {
+          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
+          "dflt": "y",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "marker": {
+          "arrowsize": {
+            "description": "Sets the size of the arrow head relative to `marker.line.width`. A value of 1 (default) gives a head about 3x as wide as the line.",
+            "dflt": 1,
             "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(domain_column=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "min": 0.3,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_arrowsize=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "editType": "calc",
-          "role": "object",
-          "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this table trace .",
-            "dflt": 0,
+          "autocolorscale": {
+            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+            "dflt": true,
             "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(domain_row=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "x": {
-            "description": "Sets the horizontal domain of this table trace (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
+          "cauto": {
+            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
+            "dflt": true,
             "editType": "calc",
-            "items": [
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_traces(domain_x=list(...), selector=dict(type='table'))"
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "y": {
-            "description": "Sets the vertical domain of this table trace (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
+          "cmax": {
+            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
+            "dflt": null,
             "editType": "calc",
-            "items": [
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_traces(domain_y=list(...), selector=dict(type='table'))"
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "magic_underscores": "fig.update_traces(domain=dict(...), selector=dict(type='table'))"
-        },
-        "cells": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans two or more lines (i.e. `text` contains one or more <br> HTML tags) or if an explicit width is set to override the text width.",
-            "dflt": "center",
+          "cmid": {
+            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
+            "dflt": null,
             "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(cells_align=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "calc",
-          "fill": {
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the cell fill color. It accepts either a specific color or an array of colors or a 2D array of colors.",
-              "dflt": "white",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(cells_fill_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "cmin": {
+            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "color": {
+            "arrayOk": true,
+            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
             "editType": "calc",
-            "role": "object",
-            "magic_underscores": "fig.update_traces(cells_fill=dict(...), selector=dict(type='table'))"
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "calc",
+          "coloraxis": {
+            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+            "dflt": null,
+            "editType": "calc",
+            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+            "valType": "subplotid",
+            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "colorbar": {
+            "bgcolor": {
+              "description": "Sets the color of padded area.",
+              "dflt": "rgba(0,0,0,0)",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(cells_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "bordercolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "colorbars",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "description": "",
-            "editType": "calc",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "calc",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(cells_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "borderwidth": {
+              "description": "Sets the width (in px) or the border enclosing this color bar.",
+              "dflt": 0,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+            "dtick": {
+              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+              "editType": "colorbars",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "calc",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+            "editType": "colorbars",
+            "exponentformat": {
+              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+              "dflt": "B",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "none",
+                "e",
+                "E",
+                "power",
+                "SI",
+                "B",
+                "SI extended"
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(cells_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(cells_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+            "labelalias": {
+              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+              "dflt": false,
+              "editType": "colorbars",
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "size": {
-              "arrayOk": true,
-              "editType": "calc",
-              "min": 1,
+            "len": {
+              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+              "dflt": 1,
+              "editType": "colorbars",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(cells_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "calc",
+            "lenmode": {
+              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+              "dflt": "fraction",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "fraction",
+                "pixels"
               ],
-              "magic_underscores": "fig.update_traces(cells_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+            "minexponent": {
+              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+              "dflt": 3,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "calc",
+            "nticks": {
+              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+              "dflt": 0,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "orientation": {
+              "description": "Sets the orientation of the colorbar.",
+              "dflt": "v",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "h",
+                "v"
               ],
-              "magic_underscores": "fig.update_traces(cells_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+            "outlinecolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "colorbars",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "calc",
+            "outlinewidth": {
+              "description": "Sets the width (in px) of the axis line.",
+              "dflt": 1,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "role": "object",
+            "separatethousands": {
+              "description": "If \"true\", even 4-digit integers are separated",
+              "dflt": false,
+              "editType": "colorbars",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "showexponent": {
+              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+              "dflt": "all",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "all",
+                "first",
+                "last",
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(cells_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+            "showticklabels": {
+              "description": "Determines whether or not the tick labels are drawn.",
+              "dflt": true,
+              "editType": "colorbars",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "calc",
-              "extras": [
-                "normal",
-                "bold"
+            "showtickprefix": {
+              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+              "dflt": "all",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
               ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(cells_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(cells_font=dict(...), selector=dict(type='table'))"
-          },
-          "format": {
-            "description": "Sets the cell value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
-            "dflt": [],
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(cells_format=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "formatsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `format`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "height": {
-            "description": "The height of cells.",
-            "dflt": 20,
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cells_height=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "line": {
-            "color": {
-              "arrayOk": true,
-              "dflt": "grey",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(cells_line_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "showticksuffix": {
+              "description": "Same as `showtickprefix` but for tick suffixes.",
+              "dflt": "all",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "editType": "calc",
-            "role": "object",
-            "width": {
-              "arrayOk": true,
-              "dflt": 1,
-              "editType": "calc",
+            "thickness": {
+              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+              "dflt": 30,
+              "editType": "colorbars",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(cells_line_width=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
+            "thicknessmode": {
+              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+              "dflt": "pixels",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "magic_underscores": "fig.update_traces(cells_line=dict(...), selector=dict(type='table'))"
-          },
-          "prefix": {
-            "arrayOk": true,
-            "description": "Prefix for cell values.",
-            "dflt": null,
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(cells_prefix=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "prefixsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `prefix`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "suffix": {
-            "arrayOk": true,
-            "description": "Suffix for cell values.",
-            "dflt": null,
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(cells_suffix=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "suffixsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `suffix`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "values": {
-            "description": "Cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.",
-            "dflt": [],
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(cells_values=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "valuessrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "magic_underscores": "fig.update_traces(cells=dict(...), selector=dict(type='table'))"
-        },
-        "header": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans two or more lines (i.e. `text` contains one or more <br> HTML tags) or if an explicit width is set to override the text width.",
-            "dflt": "center",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(header_align=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "calc",
-          "fill": {
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the cell fill color. It accepts either a specific color or an array of colors or a 2D array of colors.",
-              "dflt": "white",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(header_fill_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "tick0": {
+              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+              "editType": "colorbars",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "tickangle": {
+              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+              "dflt": "auto",
+              "editType": "colorbars",
+              "valType": "angle",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "editType": "calc",
-            "role": "object",
-            "magic_underscores": "fig.update_traces(header_fill=dict(...), selector=dict(type='table'))"
-          },
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "calc",
+            "tickcolor": {
+              "description": "Sets the tick color.",
+              "dflt": "#444",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(header_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "tickfont": {
+              "color": {
+                "editType": "colorbars",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "description": "Sets the color bar's tick label font",
+              "editType": "colorbars",
+              "family": {
+                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                "editType": "colorbars",
+                "noBlank": true,
+                "strict": true,
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "lineposition": {
+                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "extras": [
+                  "none"
+                ],
+                "flags": [
+                  "under",
+                  "over",
+                  "through"
+                ],
+                "valType": "flaglist",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "role": "object",
+              "shadow": {
+                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "size": {
+                "editType": "colorbars",
+                "min": 1,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "style": {
+                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "italic"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "textcase": {
+                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='quiver'))"
             },
-            "description": "",
-            "editType": "calc",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "calc",
-              "noBlank": true,
-              "strict": true,
+            "tickformat": {
+              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+              "dflt": "",
+              "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(header_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+            "tickformatstops": {
+              "items": {
+                "tickformatstop": {
+                  "dtickrange": {
+                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                    "editType": "colorbars",
+                    "items": [
+                      {
+                        "editType": "colorbars",
+                        "valType": "any"
+                      },
+                      {
+                        "editType": "colorbars",
+                        "valType": "any"
+                      }
+                    ],
+                    "valType": "info_array"
+                  },
+                  "editType": "colorbars",
+                  "enabled": {
+                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                    "dflt": true,
+                    "editType": "colorbars",
+                    "valType": "boolean"
+                  },
+                  "name": {
+                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                    "editType": "colorbars",
+                    "valType": "string"
+                  },
+                  "role": "object",
+                  "templateitemname": {
+                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                    "editType": "colorbars",
+                    "valType": "string"
+                  },
+                  "value": {
+                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                    "dflt": "",
+                    "editType": "colorbars",
+                    "valType": "string"
+                  }
+                }
+              },
+              "role": "object",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='quiver'))"
             },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "calc",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+            "ticklabeloverflow": {
+              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "allow",
+                "hide past div",
+                "hide past domain"
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(header_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(header_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+            "ticklabelposition": {
+              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+              "dflt": "outside",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "outside",
+                "inside",
+                "outside top",
+                "inside top",
+                "outside left",
+                "inside left",
+                "outside right",
+                "inside right",
+                "outside bottom",
+                "inside bottom"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "size": {
-              "arrayOk": true,
-              "editType": "calc",
+            "ticklabelstep": {
+              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+              "dflt": 1,
+              "editType": "colorbars",
               "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(header_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+            "ticklen": {
+              "description": "Sets the tick length (in px).",
+              "dflt": 5,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "calc",
+            "tickmode": {
+              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+              "editType": "colorbars",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "auto",
+                "linear",
+                "array"
               ],
-              "magic_underscores": "fig.update_traces(header_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+            "tickprefix": {
+              "description": "Sets a tick label prefix.",
+              "dflt": "",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "calc",
+            "ticks": {
+              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+              "dflt": "",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "outside",
+                "inside",
+                ""
               ],
-              "magic_underscores": "fig.update_traces(header_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+            "ticksuffix": {
+              "description": "Sets a tick label suffix.",
+              "dflt": "",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "calc",
+            "ticktext": {
+              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+              "editType": "colorbars",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "tickvals": {
+              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+              "editType": "colorbars",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "tickwidth": {
+              "description": "Sets the tick width (in px).",
+              "dflt": 1,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "title": {
+              "editType": "colorbars",
+              "font": {
+                "color": {
+                  "editType": "colorbars",
+                  "valType": "color",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "description": "Sets this color bar's title font.",
+                "editType": "colorbars",
+                "family": {
+                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                  "editType": "colorbars",
+                  "noBlank": true,
+                  "strict": true,
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "lineposition": {
+                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                  "dflt": "none",
+                  "editType": "colorbars",
+                  "extras": [
+                    "none"
+                  ],
+                  "flags": [
+                    "under",
+                    "over",
+                    "through"
+                  ],
+                  "valType": "flaglist",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "role": "object",
+                "shadow": {
+                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                  "dflt": "none",
+                  "editType": "colorbars",
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "size": {
+                  "editType": "colorbars",
+                  "min": 1,
+                  "valType": "number",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "style": {
+                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "italic"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "textcase": {
+                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "word caps",
+                    "upper",
+                    "lower"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "variant": {
+                  "description": "Sets the variant of the font.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "small-caps",
+                    "all-small-caps",
+                    "all-petite-caps",
+                    "petite-caps",
+                    "unicase"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "weight": {
+                  "description": "Sets the weight (or boldness) of the font.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "extras": [
+                    "normal",
+                    "bold"
+                  ],
+                  "max": 1000,
+                  "min": 1,
+                  "valType": "integer",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+                },
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='quiver'))"
+              },
+              "role": "object",
+              "side": {
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "right",
+                  "top",
+                  "bottom"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "text": {
+                "description": "Sets the title of the color bar.",
+                "editType": "colorbars",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='quiver'))"
+            },
+            "x": {
+              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+              "editType": "colorbars",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "xanchor": {
+              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "left",
+                "center",
+                "right"
               ],
-              "magic_underscores": "fig.update_traces(header_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+            "xpad": {
+              "description": "Sets the amount of padding (in px) along the x direction.",
+              "dflt": 10,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "calc",
-              "extras": [
-                "normal",
-                "bold"
+            "xref": {
+              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+              "dflt": "paper",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "container",
+                "paper"
               ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(header_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+            "y": {
+              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+              "editType": "colorbars",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "magic_underscores": "fig.update_traces(header_font=dict(...), selector=dict(type='table'))"
-          },
-          "format": {
-            "description": "Sets the cell value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
-            "dflt": [],
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(header_format=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "formatsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `format`.",
-            "editType": "none",
-            "valType": "string"
+            "yanchor": {
+              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "top",
+                "middle",
+                "bottom"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "ypad": {
+              "description": "Sets the amount of padding (in px) along the y direction.",
+              "dflt": 10,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "yref": {
+              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+              "dflt": "paper",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "container",
+                "paper"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='quiver'))"
           },
-          "height": {
-            "description": "The height of cells.",
-            "dflt": 28,
+          "colorscale": {
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "dflt": null,
             "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(header_height=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "impliedEdits": {
+              "autocolorscale": false,
+              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "valType": "colorscale",
+            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
+          "editType": "calc",
           "line": {
-            "color": {
-              "arrayOk": true,
-              "dflt": "grey",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(header_line_color=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "dash": {
+              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+              "dflt": "solid",
+              "editType": "style",
+              "valType": "string",
+              "values": [
+                "solid",
+                "dot",
+                "dash",
+                "longdash",
+                "dashdot",
+                "longdashdot"
+              ],
+              "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "editType": "calc",
+            "editType": "style",
             "role": "object",
             "width": {
-              "arrayOk": true,
-              "dflt": 1,
-              "editType": "calc",
+              "description": "Sets the width (in px) of the arrow lines.",
+              "dflt": 2,
+              "editType": "style",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(header_line_width=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "magic_underscores": "fig.update_traces(header_line=dict(...), selector=dict(type='table'))"
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='quiver'))"
           },
-          "prefix": {
+          "reversescale": {
+            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
+            "dflt": false,
+            "editType": "plot",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "role": "object",
+          "showscale": {
+            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
+            "dflt": true,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='quiver'))"
+        },
+        "textfont": {
+          "color": {
             "arrayOk": true,
-            "description": "Prefix for cell values.",
-            "dflt": null,
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "description": "Sets the text font.",
+          "editType": "calc",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
             "editType": "calc",
+            "noBlank": true,
+            "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(header_prefix=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "prefixsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `prefix`.",
-            "editType": "none",
-            "valType": "string"
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "calc",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
           "role": "object",
-          "suffix": {
+          "shadow": {
             "arrayOk": true,
-            "description": "Suffix for cell values.",
-            "dflt": null,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
             "editType": "calc",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(header_suffix=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "suffixsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `suffix`.",
-            "editType": "none",
-            "valType": "string"
+          "size": {
+            "arrayOk": true,
+            "editType": "calc",
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "values": {
-            "description": "Header cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.",
-            "dflt": [],
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
             "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(header_values=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "valuessrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-            "editType": "none",
-            "valType": "string"
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "magic_underscores": "fig.update_traces(header=dict(...), selector=dict(type='table'))"
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+          },
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='quiver'))"
+        },
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "selected": {
+          "editType": "style",
+          "marker": {
+            "color": {
+              "description": "Sets the marker color of selected points.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "editType": "style",
+            "line": {
+              "editType": "style",
+              "role": "object",
+              "width": {
+                "description": "Sets the line width of selected points.",
+                "editType": "style",
+                "min": 0,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(selected_marker_line_width=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "magic_underscores": "fig.update_traces(selected_marker_line=dict(...), selector=dict(type='quiver'))"
+            },
+            "role": "object",
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='quiver'))"
+          },
+          "role": "object",
+          "textfont": {
+            "color": {
+              "description": "Sets the text font color of selected points, applied only when a selection exists.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(selected_textfont_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "editType": "style",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(selected_textfont=dict(...), selector=dict(type='quiver'))"
+          },
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='quiver'))"
+        },
+        "unselected": {
+          "editType": "style",
+          "marker": {
+            "color": {
+              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "editType": "style",
+            "line": {
+              "editType": "style",
+              "role": "object",
+              "width": {
+                "description": "Sets the line width of unselected points, applied only when a selection exists.",
+                "editType": "style",
+                "min": 0,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(unselected_marker_line_width=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+              },
+              "magic_underscores": "fig.update_traces(unselected_marker_line=dict(...), selector=dict(type='quiver'))"
+            },
+            "role": "object",
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='quiver'))"
+          },
+          "role": "object",
+          "textfont": {
+            "color": {
+              "description": "Sets the text font color of unselected points, applied only when a selection exists.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(unselected_textfont_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+            },
+            "editType": "style",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(unselected_textfont=dict(...), selector=dict(type='quiver'))"
+          },
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='quiver'))"
+        },
+        "anchor": {
+          "description": "Sets the arrows' anchor with respect to their (x,y) positions. Use *tail* to place (x,y) at the base, *tip* to place (x,y) at the head, or *center* to center the arrow on (x,y).",
+          "dflt": "tail",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "tip",
+            "tail",
+            "center"
+          ],
+          "magic_underscores": "fig.update_traces(anchor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
         "hoverlabel": {
           "align": {
@@ -33636,36 +31730,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
           "editType": "none",
           "font": {
@@ -33673,12 +31752,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -33689,12 +31763,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -33710,12 +31779,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "role": "object",
             "shadow": {
@@ -33724,24 +31788,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "style": {
               "arrayOk": true,
@@ -33753,12 +31807,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -33772,12 +31821,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "variant": {
               "arrayOk": true,
@@ -33793,12 +31837,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
             "weight": {
               "arrayOk": true,
@@ -33812,14 +31851,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='quiver'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='table'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='quiver'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -33828,12 +31862,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
           "role": "object",
           "showarrow": {
@@ -33841,64 +31870,75 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='table'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='quiver'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='table'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='table'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='quiver'))"
         },
-        "stream": {
+        "sizemode": {
+          "description": "Determines whether arrows are drawn according to their raw lengths, or scaled based on the maximum vector length and point density. Note: When `anglemode` is *data* arrows are alwyas scaled and `sizemode` *raw* is ignored.",
+          "dflt": "scaled",
           "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='table'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='table'))"
+          "valType": "enumerated",
+          "values": [
+            "scaled",
+            "raw"
+          ],
+          "magic_underscores": "fig.update_traces(sizemode=&lt;VALUE&gt;, selector=dict(type='quiver'))"
         },
-        "editType": "calc",
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='table'))"
+        "sizeref": {
+          "description": "Adjusts the arrow size scaling. The arrow length is determined by the vector norm multiplied by `sizeref`, optionally normalized when `sizemode` is *scaled* (`sizeref` is applied after scaling).",
+          "dflt": 1,
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(sizeref=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "anglemode": {
+          "description": "Sets the mode used to determine the angle of the arrow vectors. If *paper*, u/v are interpreted in pixel coordinates and the rendered vector angle does not change regardless of the axes scales. If *data*, u/v are interpreted in data coordinates and the rendered vector angle may change, e.g. if zooming in along a single axis",
+          "dflt": "axis",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "paper",
+            "data"
+          ],
+          "magic_underscores": "fig.update_traces(anglemode=&lt;VALUE&gt;, selector=dict(type='quiver'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='quiver'))"
       },
       "categories": [
-        "noOpacity"
+        "cartesian",
+        "svg",
+        "showLegend",
+        "scatter-like",
+        "zoomScale"
       ],
       "meta": {
-        "description": "Table view for detailed data viewing. The data are arranged in a grid of rows and columns. Most styling can be specified for columns, rows or individual cells. Table is using a column-major order, ie. the grid is represented as a vector of column vectors."
+        "description": "The quiver trace type visualizes vector fields using arrows. Specify a vector field using 4 1D arrays: 2 position arrays `x`, `y` and 2 vector component arrays `u`, `v`. The arrows are drawn exactly at the positions given by `x` and `y`. Arrow length and direction are determined by `u` and `v` components."
       },
-      "type": "table"
+      "type": "quiver"
     },
-    "box": {
+    "table": {
       "animatable": false,
       "attributes": {
-        "type": "box",
+        "type": "table",
         "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover. For box traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical",
-          "editType": "calc+clearAxisTypes",
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
+          "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -33910,35 +31950,21 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -33946,7 +31972,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -33956,7 +31982,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -33971,7 +31997,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "role": "object",
             "shadow": {
@@ -33979,13 +32005,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -33996,7 +32022,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -34009,7 +32035,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -34024,7 +32050,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -34037,9 +32063,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='box'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='table'))"
           },
           "role": "object",
           "text": {
@@ -34047,127 +32073,40 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='box'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='table'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='table'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "zorder": {
-          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
-          "dflt": 0,
-          "editType": "plot",
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "x": {
-          "description": "Sets the x sample data or coordinates. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x0": {
-          "description": "Sets the x coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
-        "dx": {
-          "description": "Sets the x coordinate step for multi-box traces set using q1/median/q3.",
+        "columnorder": {
+          "description": "Specifies the rendered order of the data columns; for example, a value `2` at position `0` means that column index `0` in the data will be rendered as the third column, as columns have an index base of zero.",
           "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(dx=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "y": {
-          "description": "Sets the y sample data or coordinates. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y0": {
-          "description": "Sets the y coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "dy": {
-          "description": "Sets the y coordinate step for multi-box traces set using q1/median/q3.",
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(dy=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "width": {
-          "description": "Sets the width of the box in data coordinate If *0* (default value) the width is automatically selected based on the positions of other box traces in the same subplot.",
-          "dflt": 0,
-          "editType": "calc",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(columnorder=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
-        "text": {
+        "columnwidth": {
           "arrayOk": true,
-          "description": "Sets the text elements associated with each sample value. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
-          "dflt": "",
+          "description": "The width of columns expressed as a ratio. Columns fill the available width in proportion of their specified column widths.",
+          "dflt": null,
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Same as `text`.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(columnwidth=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -34183,1067 +32122,731 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xaxis": {
-          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
-          "dflt": "x",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "yaxis": {
-          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
-          "dflt": "y",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "orientation": {
-          "description": "Sets the orientation of the box(es). If *v* (*h*), the distribution is visualized along the vertical (horizontal).",
-          "editType": "calc+clearAxisTypes",
-          "valType": "enumerated",
-          "values": [
-            "v",
-            "h"
-          ],
-          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "alignmentgroup": {
-          "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "offsetgroup": {
-          "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "xperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
-          "dflt": 0,
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "xperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
-          "dflt": "middle",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "start",
-            "middle",
-            "end"
-          ],
-          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "xperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "yperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the y axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
-          "dflt": 0,
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(yperiod=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "yperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the y axis.",
-          "dflt": "middle",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "start",
-            "middle",
-            "end"
-          ],
-          "magic_underscores": "fig.update_traces(yperiodalignment=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='table'))"
         },
-        "yperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the y0 axis. When `y0period` is round number of weeks, the `y0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+        "domain": {
+          "column": {
+            "description": "If there is a layout grid, use the domain for this column in the grid for this table trace.",
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(domain_column=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(yperiod0=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "marker": {
-          "angle": {
-            "arrayOk": false,
-            "description": "Sets the marker angle in respect to `angleref`.",
+          "role": "object",
+          "row": {
+            "description": "If there is a layout grid, use the domain for this row in the grid for this table trace.",
             "dflt": 0,
             "editType": "calc",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='box'))"
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(domain_row=&lt;VALUE&gt;, selector=dict(type='table'))"
           },
-          "color": {
-            "arrayOk": false,
-            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "x": {
+            "description": "Sets the horizontal domain of this table trace (in plot fraction).",
+            "dflt": [
+              0,
+              1
+            ],
+            "editType": "calc",
+            "items": [
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              },
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              }
+            ],
+            "valType": "info_array",
+            "magic_underscores": "fig.update_traces(domain_x=list(...), selector=dict(type='table'))"
           },
-          "editType": "plot",
-          "line": {
+          "y": {
+            "description": "Sets the vertical domain of this table trace (in plot fraction).",
+            "dflt": [
+              0,
+              1
+            ],
+            "editType": "calc",
+            "items": [
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              },
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              }
+            ],
+            "valType": "info_array",
+            "magic_underscores": "fig.update_traces(domain_y=list(...), selector=dict(type='table'))"
+          },
+          "magic_underscores": "fig.update_traces(domain=dict(...), selector=dict(type='table'))"
+        },
+        "cells": {
+          "align": {
+            "arrayOk": true,
+            "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans two or more lines (i.e. `text` contains one or more <br> HTML tags) or if an explicit width is set to override the text width.",
+            "dflt": "center",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "center",
+              "right"
+            ],
+            "magic_underscores": "fig.update_traces(cells_align=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "editType": "calc",
+          "fill": {
             "color": {
-              "arrayOk": false,
-              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
-              "dflt": "#444",
-              "editType": "style",
+              "arrayOk": true,
+              "description": "Sets the cell fill color. It accepts either a specific color or an array of colors or a 2D array of colors.",
+              "dflt": "white",
+              "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(cells_fill_color=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
-            "editType": "style",
-            "outliercolor": {
-              "description": "Sets the border line color of the outlier sample points. Defaults to marker.color",
-              "editType": "style",
+            "editType": "calc",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(cells_fill=dict(...), selector=dict(type='table'))"
+          },
+          "font": {
+            "color": {
+              "arrayOk": true,
+              "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_outliercolor=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(cells_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
-            "outlierwidth": {
-              "description": "Sets the border line width (in px) of the outlier sample points.",
-              "dflt": 1,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_outlierwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
+            "description": "",
+            "editType": "calc",
+            "family": {
+              "arrayOk": true,
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "calc",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(cells_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "lineposition": {
+              "arrayOk": true,
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "calc",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(cells_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
             "role": "object",
-            "width": {
-              "arrayOk": false,
-              "description": "Sets the width (in px) of the lines bounding the marker points.",
-              "dflt": 0,
-              "editType": "style",
-              "min": 0,
+            "shadow": {
+              "arrayOk": true,
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "calc",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(cells_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "size": {
+              "arrayOk": true,
+              "editType": "calc",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(cells_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
             },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='box'))"
-          },
-          "opacity": {
-            "arrayOk": false,
-            "description": "Sets the marker opacity.",
-            "dflt": 1,
-            "editType": "style",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
-          "outliercolor": {
-            "description": "Sets the color of the outlier sample points.",
-            "dflt": "rgba(0, 0, 0, 0)",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_outliercolor=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
+            "style": {
+              "arrayOk": true,
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(cells_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "textcase": {
+              "arrayOk": true,
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(cells_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "variant": {
+              "arrayOk": true,
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(cells_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "weight": {
+              "arrayOk": true,
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "calc",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(cells_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "magic_underscores": "fig.update_traces(cells_font=dict(...), selector=dict(type='table'))"
+          },
+          "format": {
+            "description": "Sets the cell value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
+            "dflt": [],
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(cells_format=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "height": {
+            "description": "The height of cells.",
+            "dflt": 20,
+            "editType": "calc",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(cells_height=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "line": {
+            "color": {
+              "arrayOk": true,
+              "dflt": "grey",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(cells_line_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "editType": "calc",
+            "role": "object",
+            "width": {
+              "arrayOk": true,
+              "dflt": 1,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(cells_line_width=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "magic_underscores": "fig.update_traces(cells_line=dict(...), selector=dict(type='table'))"
+          },
+          "prefix": {
+            "arrayOk": true,
+            "description": "Prefix for cell values.",
+            "dflt": null,
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(cells_prefix=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
           "role": "object",
-          "size": {
-            "arrayOk": false,
-            "description": "Sets the marker size (in px).",
-            "dflt": 6,
+          "suffix": {
+            "arrayOk": true,
+            "description": "Suffix for cell values.",
+            "dflt": null,
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(cells_suffix=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "values": {
+            "description": "Cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.",
+            "dflt": [],
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(cells_values=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "magic_underscores": "fig.update_traces(cells=dict(...), selector=dict(type='table'))"
+        },
+        "header": {
+          "align": {
+            "arrayOk": true,
+            "description": "Sets the horizontal alignment of the `text` within the box. Has an effect only if `text` spans two or more lines (i.e. `text` contains one or more <br> HTML tags) or if an explicit width is set to override the text width.",
+            "dflt": "center",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "center",
+              "right"
+            ],
+            "magic_underscores": "fig.update_traces(header_align=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "editType": "calc",
+          "fill": {
+            "color": {
+              "arrayOk": true,
+              "description": "Sets the cell fill color. It accepts either a specific color or an array of colors or a 2D array of colors.",
+              "dflt": "white",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(header_fill_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "editType": "calc",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(header_fill=dict(...), selector=dict(type='table'))"
+          },
+          "font": {
+            "color": {
+              "arrayOk": true,
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(header_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "description": "",
+            "editType": "calc",
+            "family": {
+              "arrayOk": true,
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "calc",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(header_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "lineposition": {
+              "arrayOk": true,
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "calc",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(header_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "role": "object",
+            "shadow": {
+              "arrayOk": true,
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "calc",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(header_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "size": {
+              "arrayOk": true,
+              "editType": "calc",
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(header_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "style": {
+              "arrayOk": true,
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(header_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "textcase": {
+              "arrayOk": true,
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(header_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "variant": {
+              "arrayOk": true,
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(header_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "weight": {
+              "arrayOk": true,
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "calc",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(header_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "magic_underscores": "fig.update_traces(header_font=dict(...), selector=dict(type='table'))"
+          },
+          "format": {
+            "description": "Sets the cell value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
+            "dflt": [],
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(header_format=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "height": {
+            "description": "The height of cells.",
+            "dflt": 28,
             "editType": "calc",
-            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='box'))"
+            "magic_underscores": "fig.update_traces(header_height=&lt;VALUE&gt;, selector=dict(type='table'))"
           },
-          "symbol": {
-            "arrayOk": false,
-            "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
-            "dflt": "circle",
-            "editType": "plot",
+          "line": {
+            "color": {
+              "arrayOk": true,
+              "dflt": "grey",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(header_line_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "editType": "calc",
+            "role": "object",
+            "width": {
+              "arrayOk": true,
+              "dflt": 1,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(header_line_width=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "magic_underscores": "fig.update_traces(header_line=dict(...), selector=dict(type='table'))"
+          },
+          "prefix": {
+            "arrayOk": true,
+            "description": "Prefix for cell values.",
+            "dflt": null,
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(header_prefix=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "role": "object",
+          "suffix": {
+            "arrayOk": true,
+            "description": "Suffix for cell values.",
+            "dflt": null,
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(header_suffix=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "values": {
+            "description": "Header cell values. `values[m][n]` represents the value of the `n`th point in column `m`, therefore the `values[m]` vector length for all columns must be the same (longer vectors will be truncated). Each value must be a finite number or a string.",
+            "dflt": [],
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(header_values=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "magic_underscores": "fig.update_traces(header=dict(...), selector=dict(type='table'))"
+        },
+        "hoverlabel": {
+          "align": {
+            "arrayOk": true,
+            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
+            "dflt": "auto",
+            "editType": "none",
             "valType": "enumerated",
             "values": [
-              0,
-              "0",
-              "circle",
-              100,
-              "100",
-              "circle-open",
-              200,
-              "200",
-              "circle-dot",
-              300,
-              "300",
-              "circle-open-dot",
-              1,
-              "1",
-              "square",
-              101,
-              "101",
-              "square-open",
-              201,
-              "201",
-              "square-dot",
-              301,
-              "301",
-              "square-open-dot",
-              2,
-              "2",
-              "diamond",
-              102,
-              "102",
-              "diamond-open",
-              202,
-              "202",
-              "diamond-dot",
-              302,
-              "302",
-              "diamond-open-dot",
-              3,
-              "3",
-              "cross",
-              103,
-              "103",
-              "cross-open",
-              203,
-              "203",
-              "cross-dot",
-              303,
-              "303",
-              "cross-open-dot",
-              4,
-              "4",
-              "x",
-              104,
-              "104",
-              "x-open",
-              204,
-              "204",
-              "x-dot",
-              304,
-              "304",
-              "x-open-dot",
-              5,
-              "5",
-              "triangle-up",
-              105,
-              "105",
-              "triangle-up-open",
-              205,
-              "205",
-              "triangle-up-dot",
-              305,
-              "305",
-              "triangle-up-open-dot",
-              6,
-              "6",
-              "triangle-down",
-              106,
-              "106",
-              "triangle-down-open",
-              206,
-              "206",
-              "triangle-down-dot",
-              306,
-              "306",
-              "triangle-down-open-dot",
-              7,
-              "7",
-              "triangle-left",
-              107,
-              "107",
-              "triangle-left-open",
-              207,
-              "207",
-              "triangle-left-dot",
-              307,
-              "307",
-              "triangle-left-open-dot",
-              8,
-              "8",
-              "triangle-right",
-              108,
-              "108",
-              "triangle-right-open",
-              208,
-              "208",
-              "triangle-right-dot",
-              308,
-              "308",
-              "triangle-right-open-dot",
-              9,
-              "9",
-              "triangle-ne",
-              109,
-              "109",
-              "triangle-ne-open",
-              209,
-              "209",
-              "triangle-ne-dot",
-              309,
-              "309",
-              "triangle-ne-open-dot",
-              10,
-              "10",
-              "triangle-se",
-              110,
-              "110",
-              "triangle-se-open",
-              210,
-              "210",
-              "triangle-se-dot",
-              310,
-              "310",
-              "triangle-se-open-dot",
-              11,
-              "11",
-              "triangle-sw",
-              111,
-              "111",
-              "triangle-sw-open",
-              211,
-              "211",
-              "triangle-sw-dot",
-              311,
-              "311",
-              "triangle-sw-open-dot",
-              12,
-              "12",
-              "triangle-nw",
-              112,
-              "112",
-              "triangle-nw-open",
-              212,
-              "212",
-              "triangle-nw-dot",
-              312,
-              "312",
-              "triangle-nw-open-dot",
-              13,
-              "13",
-              "pentagon",
-              113,
-              "113",
-              "pentagon-open",
-              213,
-              "213",
-              "pentagon-dot",
-              313,
-              "313",
-              "pentagon-open-dot",
-              14,
-              "14",
-              "hexagon",
-              114,
-              "114",
-              "hexagon-open",
-              214,
-              "214",
-              "hexagon-dot",
-              314,
-              "314",
-              "hexagon-open-dot",
-              15,
-              "15",
-              "hexagon2",
-              115,
-              "115",
-              "hexagon2-open",
-              215,
-              "215",
-              "hexagon2-dot",
-              315,
-              "315",
-              "hexagon2-open-dot",
-              16,
-              "16",
-              "octagon",
-              116,
-              "116",
-              "octagon-open",
-              216,
-              "216",
-              "octagon-dot",
-              316,
-              "316",
-              "octagon-open-dot",
-              17,
-              "17",
-              "star",
-              117,
-              "117",
-              "star-open",
-              217,
-              "217",
-              "star-dot",
-              317,
-              "317",
-              "star-open-dot",
-              18,
-              "18",
-              "hexagram",
-              118,
-              "118",
-              "hexagram-open",
-              218,
-              "218",
-              "hexagram-dot",
-              318,
-              "318",
-              "hexagram-open-dot",
-              19,
-              "19",
-              "star-triangle-up",
-              119,
-              "119",
-              "star-triangle-up-open",
-              219,
-              "219",
-              "star-triangle-up-dot",
-              319,
-              "319",
-              "star-triangle-up-open-dot",
-              20,
-              "20",
-              "star-triangle-down",
-              120,
-              "120",
-              "star-triangle-down-open",
-              220,
-              "220",
-              "star-triangle-down-dot",
-              320,
-              "320",
-              "star-triangle-down-open-dot",
-              21,
-              "21",
-              "star-square",
-              121,
-              "121",
-              "star-square-open",
-              221,
-              "221",
-              "star-square-dot",
-              321,
-              "321",
-              "star-square-open-dot",
-              22,
-              "22",
-              "star-diamond",
-              122,
-              "122",
-              "star-diamond-open",
-              222,
-              "222",
-              "star-diamond-dot",
-              322,
-              "322",
-              "star-diamond-open-dot",
-              23,
-              "23",
-              "diamond-tall",
-              123,
-              "123",
-              "diamond-tall-open",
-              223,
-              "223",
-              "diamond-tall-dot",
-              323,
-              "323",
-              "diamond-tall-open-dot",
-              24,
-              "24",
-              "diamond-wide",
-              124,
-              "124",
-              "diamond-wide-open",
-              224,
-              "224",
-              "diamond-wide-dot",
-              324,
-              "324",
-              "diamond-wide-open-dot",
-              25,
-              "25",
-              "hourglass",
-              125,
-              "125",
-              "hourglass-open",
-              26,
-              "26",
-              "bowtie",
-              126,
-              "126",
-              "bowtie-open",
-              27,
-              "27",
-              "circle-cross",
-              127,
-              "127",
-              "circle-cross-open",
-              28,
-              "28",
-              "circle-x",
-              128,
-              "128",
-              "circle-x-open",
-              29,
-              "29",
-              "square-cross",
-              129,
-              "129",
-              "square-cross-open",
-              30,
-              "30",
-              "square-x",
-              130,
-              "130",
-              "square-x-open",
-              31,
-              "31",
-              "diamond-cross",
-              131,
-              "131",
-              "diamond-cross-open",
-              32,
-              "32",
-              "diamond-x",
-              132,
-              "132",
-              "diamond-x-open",
-              33,
-              "33",
-              "cross-thin",
-              133,
-              "133",
-              "cross-thin-open",
-              34,
-              "34",
-              "x-thin",
-              134,
-              "134",
-              "x-thin-open",
-              35,
-              "35",
-              "asterisk",
-              135,
-              "135",
-              "asterisk-open",
-              36,
-              "36",
-              "hash",
-              136,
-              "136",
-              "hash-open",
-              236,
-              "236",
-              "hash-dot",
-              336,
-              "336",
-              "hash-open-dot",
-              37,
-              "37",
-              "y-up",
-              137,
-              "137",
-              "y-up-open",
-              38,
-              "38",
-              "y-down",
-              138,
-              "138",
-              "y-down-open",
-              39,
-              "39",
-              "y-left",
-              139,
-              "139",
-              "y-left-open",
-              40,
-              "40",
-              "y-right",
-              140,
-              "140",
-              "y-right-open",
-              41,
-              "41",
-              "line-ew",
-              141,
-              "141",
-              "line-ew-open",
-              42,
-              "42",
-              "line-ns",
-              142,
-              "142",
-              "line-ns-open",
-              43,
-              "43",
-              "line-ne",
-              143,
-              "143",
-              "line-ne-open",
-              44,
-              "44",
-              "line-nw",
-              144,
-              "144",
-              "line-nw-open",
-              45,
-              "45",
-              "arrow-up",
-              145,
-              "145",
-              "arrow-up-open",
-              46,
-              "46",
-              "arrow-down",
-              146,
-              "146",
-              "arrow-down-open",
-              47,
-              "47",
-              "arrow-left",
-              147,
-              "147",
-              "arrow-left-open",
-              48,
-              "48",
-              "arrow-right",
-              148,
-              "148",
-              "arrow-right-open",
-              49,
-              "49",
-              "arrow-bar-up",
-              149,
-              "149",
-              "arrow-bar-up-open",
-              50,
-              "50",
-              "arrow-bar-down",
-              150,
-              "150",
-              "arrow-bar-down-open",
-              51,
-              "51",
-              "arrow-bar-left",
-              151,
-              "151",
-              "arrow-bar-left-open",
-              52,
-              "52",
-              "arrow-bar-right",
-              152,
-              "152",
-              "arrow-bar-right-open",
-              53,
-              "53",
-              "arrow",
-              153,
-              "153",
-              "arrow-open",
-              54,
-              "54",
-              "arrow-wide",
-              154,
-              "154",
-              "arrow-wide-open"
+              "left",
+              "right",
+              "auto"
             ],
-            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='box'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='table'))"
           },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='box'))"
-        },
-        "line": {
-          "color": {
-            "description": "Sets the color of line bounding the box(es).",
-            "editType": "style",
+          "bgcolor": {
+            "arrayOk": true,
+            "description": "Sets the background color of the hover labels for this trace",
+            "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='box'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "bordercolor": {
+            "arrayOk": true,
+            "description": "Sets the border color of the hover labels for this trace.",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='table'))"
+          },
+          "editType": "none",
+          "font": {
+            "color": {
+              "arrayOk": true,
+              "editType": "none",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "description": "Sets the font used in hover labels.",
+            "editType": "none",
+            "family": {
+              "arrayOk": true,
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "none",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "lineposition": {
+              "arrayOk": true,
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "none",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "role": "object",
+            "shadow": {
+              "arrayOk": true,
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "none",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "size": {
+              "arrayOk": true,
+              "editType": "none",
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "style": {
+              "arrayOk": true,
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "textcase": {
+              "arrayOk": true,
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "variant": {
+              "arrayOk": true,
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "weight": {
+              "arrayOk": true,
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "none",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='table'))"
+            },
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='table'))"
+          },
+          "namelength": {
+            "arrayOk": true,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='table'))"
           },
-          "editType": "plot",
           "role": "object",
-          "width": {
-            "description": "Sets the width (in px) of line bounding the box(es).",
-            "dflt": 2,
-            "editType": "style",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='table'))"
           },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='table'))"
         },
-        "boxmean": {
-          "description": "If *true*, the mean of the box(es)' underlying distribution is drawn as a dashed line inside the box(es). If *sd* the standard deviation is also drawn. Defaults to *true* when `mean` is set. Defaults to *sd* when `sd` is set Otherwise defaults to *false*.",
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='table'))"
+        },
+        "editType": "calc",
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='table'))"
+      },
+      "categories": [
+        "noOpacity"
+      ],
+      "meta": {
+        "description": "Table view for detailed data viewing. The data are arranged in a grid of rows and columns. Most styling can be specified for columns, rows or individual cells. Table is using a column-major order, ie. the grid is represented as a vector of column vectors."
+      },
+      "type": "table"
+    },
+    "box": {
+      "animatable": false,
+      "attributes": {
+        "type": "box",
+        "name": {
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover. For box traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical",
+          "editType": "calc+clearAxisTypes",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "uid": {
+          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
           "editType": "calc",
           "valType": "enumerated",
           "values": [
             true,
-            "sd",
-            false
+            false,
+            "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(boxmean=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "boxpoints": {
-          "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the box(es) are shown with no sample points Defaults to *suspectedoutliers* when `marker.outliercolor` or `marker.line.outliercolor` is set. Defaults to *all* under the q1/median/q3 signature. Otherwise defaults to *outliers*.",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "all",
-            "outliers",
-            "suspectedoutliers",
-            false
-          ],
-          "magic_underscores": "fig.update_traces(boxpoints=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "notched": {
-          "description": "Determines whether or not notches are drawn. Notches displays a confidence interval around the median. We compute the confidence interval as median +/- 1.57 * IQR / sqrt(N), where IQR is the interquartile range and N is the sample size. If two boxes' notches do not overlap there is 95% confidence their medians differ. See https://sites.google.com/site/davidsstatistics/home/notched-box-plots for more info. Defaults to *false* unless `notchwidth` or `notchspan` is set.",
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(notched=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "notchwidth": {
-          "description": "Sets the width of the notches relative to the box width. For example, with 0, the notches are as wide as the box(es).",
-          "dflt": 0.25,
-          "editType": "calc",
-          "max": 0.5,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(notchwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "showwhiskers": {
-          "description": "Determines whether or not whiskers are visible. Defaults to true for `sizemode` *quartiles*, false for *sd*.",
-          "editType": "calc",
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showwhiskers=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "whiskerwidth": {
-          "description": "Sets the width of the whiskers relative to the box width. For example, with 1, the whiskers are as wide as the box(es).",
-          "dflt": 0.5,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(whiskerwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "q1": {
-          "description": "Sets the Quartile 1 values. There should be as many items as the number of boxes desired.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(q1=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "median": {
-          "description": "Sets the median values. There should be as many items as the number of boxes desired.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(median=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "q3": {
-          "description": "Sets the Quartile 3 values. There should be as many items as the number of boxes desired.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(q3=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "lowerfence": {
-          "description": "Sets the lower fence values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `lowerfence` is not provided but a sample (in `y` or `x`) is set, we compute the lower as the last sample point below 1.5 times the IQR.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lowerfence=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "upperfence": {
-          "description": "Sets the upper fence values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `upperfence` is not provided but a sample (in `y` or `x`) is set, we compute the upper as the last sample point above 1.5 times the IQR.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(upperfence=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "notchspan": {
-          "description": "Sets the notch span from the boxes' `median` values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `notchspan` is not provided but a sample (in `y` or `x`) is set, we compute it as 1.57 * IQR / sqrt(N), where N is the sample size.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(notchspan=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "mean": {
-          "description": "Sets the mean values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `mean` is not provided but a sample (in `y` or `x`) is set, we compute the mean for each box using the sample values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(mean=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "sd": {
-          "description": "Sets the standard deviation values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `sd` is not provided but a sample (in `y` or `x`) is set, we compute the standard deviation for each box using the sample values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(sd=&lt;VALUE&gt;, selector=dict(type='box'))"
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "sdmultiple": {
-          "description": "Scales the box size when sizemode=sd Allowing boxes to be drawn across any stddev range For example 1-stddev, 3-stddev, 5-stddev",
-          "dflt": 1,
-          "editType": "calc",
-          "min": 0,
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(sdmultiple=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "quartilemethod": {
-          "description": "Sets the method used to compute the sample's Q1 and Q3 quartiles. The *linear* method uses the 25th percentile for Q1 and 75th percentile for Q3 as computed using method #10 (listed on http://jse.amstat.org/v14n3/langford.html). The *exclusive* method uses the median to divide the ordered dataset into two halves if the sample is odd, it does not include the median in either half - Q1 is then the median of the lower half and Q3 the median of the upper half. The *inclusive* method also uses the median to divide the ordered dataset into two halves but if the sample is odd, it includes the median in both halves - Q1 is then the median of the lower half and Q3 the median of the upper half.",
-          "dflt": "linear",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "linear",
-            "exclusive",
-            "inclusive"
-          ],
-          "magic_underscores": "fig.update_traces(quartilemethod=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "q1src": {
-          "description": "Sets the source reference on Chart Studio Cloud for `q1`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "mediansrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `median`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "q3src": {
-          "description": "Sets the source reference on Chart Studio Cloud for `q3`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "lowerfencesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lowerfence`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "upperfencesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `upperfence`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "notchspansrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `notchspan`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "meansrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `mean`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "sdsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `sd`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "selected": {
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
           "editType": "style",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of selected points.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "editType": "style",
-            "opacity": {
-              "description": "Sets the marker opacity of selected points.",
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "role": "object",
-            "size": {
-              "description": "Sets the marker size of selected points.",
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='box'))"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='box'))"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "unselected": {
+        "legendgrouptitle": {
           "editType": "style",
-          "marker": {
+          "font": {
             "color": {
-              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='box'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
+            "description": "Sets this legend group's title font.",
             "editType": "style",
-            "opacity": {
-              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "role": "object",
-            "size": {
-              "description": "Sets the marker size of unselected points, applied only when a selection exists.",
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='box'))"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='box'))"
-        },
-        "fillcolor": {
-          "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
-          "editType": "style",
-          "valType": "color",
-          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "right",
-              "auto"
-            ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bordercolor": {
-            "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "none",
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "none",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
             "family": {
-              "arrayOk": true,
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
+              "editType": "style",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "lineposition": {
-              "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "none",
+              "editType": "style",
               "extras": [
                 "none"
               ],
@@ -35253,61 +32856,37 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "role": "object",
             "shadow": {
-              "arrayOk": true,
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "none",
+              "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "size": {
-              "arrayOk": true,
-              "editType": "none",
+              "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "style": {
-              "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "textcase": {
-              "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -35315,18 +32894,12 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "variant": {
-              "arrayOk": true,
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -35336,18 +32909,12 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "weight": {
-              "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "style",
               "extras": [
                 "normal",
                 "bold"
@@ -35355,442 +32922,92 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='box'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='box'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='box'))"
           },
           "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='box'))"
         },
-        "hoveron": {
-          "description": "Do the hover effects highlight individual boxes or sample points or both?",
-          "dflt": "boxes+points",
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
-          "flags": [
-            "boxes",
-            "points"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoveron=&lt;VALUE&gt;, selector=dict(type='box'))"
-        },
-        "pointpos": {
-          "description": "Sets the position of the sample points in relation to the box(es). If *0*, the sample points are places over the center of the box(es). Positive (negative) values correspond to positions to the right (left) for vertical boxes and above (below) for horizontal boxes",
-          "editType": "calc",
-          "max": 2,
-          "min": -2,
+          "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(pointpos=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "jitter": {
-          "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the box(es).",
-          "editType": "calc",
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(jitter=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "sizemode": {
-          "description": "Sets the upper and lower bound for the boxes quartiles means box is drawn between Q1 and Q3 SD means the box is drawn between Mean +- Standard Deviation Argument sdmultiple (default 1) to scale the box size So it could be drawn 1-stddev, 3-stddev etc",
-          "dflt": "quartiles",
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "quartiles",
-            "sd"
-          ],
-          "magic_underscores": "fig.update_traces(sizemode=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='box'))"
+        "zorder": {
+          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
+          "dflt": 0,
+          "editType": "plot",
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "ycalendar": {
-          "description": "Sets the calendar system to use with `y` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='box'))"
+        "x": {
+          "description": "Sets the x sample data or coordinates. See overview for more info.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
+        "x0": {
+          "description": "Sets the x coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
+          "editType": "calc+clearAxisTypes",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='box'))"
+          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "stream": {
+        "dx": {
+          "description": "Sets the x coordinate step for multi-box traces set using q1/median/q3.",
           "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='box'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='box'))"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(dx=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='box'))"
-      },
-      "categories": [
-        "cartesian",
-        "svg",
-        "symbols",
-        "oriented",
-        "box-violin",
-        "showLegend",
-        "boxLayout",
-        "zoomScale"
-      ],
-      "layoutAttributes": {
-        "boxgap": {
-          "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates. Has no effect on traces that have *width* set.",
-          "dflt": 0.3,
+        "y": {
+          "description": "Sets the y sample data or coordinates. See overview for more info.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "y0": {
+          "description": "Sets the y coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "dy": {
+          "description": "Sets the y coordinate step for multi-box traces set using q1/median/q3.",
           "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(dy=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "boxgroupgap": {
-          "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate. Has no effect on traces that have *width* set.",
-          "dflt": 0.3,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
-        },
-        "boxmode": {
-          "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes. Has no effect on traces that have *width* set.",
-          "dflt": "overlay",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "group",
-            "overlay"
-          ]
-        }
-      },
-      "meta": {
-        "description": "Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The second quartile (Q2, i.e. the median) is marked by a line inside the box. The fences grow outward from the boxes' edges, by default they span +/- 1.5 times the interquartile range (IQR: Q3-Q1), The sample mean and standard deviation as well as notches and the sample, outlier and suspected outliers points can be optionally added to the box plot. The values and positions corresponding to each boxes can be input using two signatures. The first signature expects users to supply the sample values in the `y` data array for vertical boxes (`x` for horizontal boxes). By supplying an `x` (`y`) array, one box per distinct `x` (`y`) value is drawn If no `x` (`y`) {array} is provided, a single box is drawn. In this case, the box is positioned with the trace `name` or with `x0` (`y0`) if provided. The second signature expects users to supply the boxes corresponding Q1, median and Q3 statistics in the `q1`, `median` and `q3` data arrays respectively. Other box features relying on statistics namely `lowerfence`, `upperfence`, `notchspan` can be set directly by the users. To have plotly compute them or to show sample points besides the boxes, users can set the `y` data array for vertical boxes (`x` for horizontal boxes) to a 2D array with the outer length corresponding to the number of boxes in the traces and the inner length corresponding the sample size."
-      },
-      "type": "box"
-    },
-    "violin": {
-      "animatable": false,
-      "attributes": {
-        "type": "violin",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover. For violin traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical. Note that the trace name is also used as a default value for attribute `scalegroup` (please see its description for details).",
-          "editType": "calc+clearAxisTypes",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "size": {
-              "editType": "style",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='violin'))"
-          },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='violin'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "zorder": {
-          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
-          "dflt": 0,
-          "editType": "plot",
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "x": {
-          "description": "Sets the x sample data or coordinates. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x0": {
-          "description": "Sets the x coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "y": {
-          "description": "Sets the y sample data or coordinates. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y0": {
-          "description": "Sets the y coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "width": {
-          "description": "Sets the width of the violin in data coordinates. If *0* (default value) the width is automatically selected based on the positions of other violin traces in the same subplot.",
-          "dflt": 0,
+        "width": {
+          "description": "Sets the width of the box in data coordinate If *0* (default value) the width is automatically selected based on the positions of other box traces in the same subplot.",
+          "dflt": 0,
           "editType": "calc",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "text": {
           "arrayOk": true,
@@ -35798,12 +33015,7 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "hovertext": {
           "arrayOk": true,
@@ -35811,16 +33023,11 @@
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -35836,12 +33043,7 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "hovertemplate": {
           "arrayOk": true,
@@ -35849,94 +33051,129 @@
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "yaxis": {
           "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
           "dflt": "y",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "orientation": {
-          "description": "Sets the orientation of the violin(s). If *v* (*h*), the distribution is visualized along the vertical (horizontal).",
+          "description": "Sets the orientation of the box(es). If *v* (*h*), the distribution is visualized along the vertical (horizontal).",
           "editType": "calc+clearAxisTypes",
           "valType": "enumerated",
           "values": [
             "v",
             "h"
           ],
-          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "alignmentgroup": {
           "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "offsetgroup": {
           "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "xperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "xperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
+          "dflt": "middle",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "start",
+            "middle",
+            "end"
+          ],
+          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "xperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "yperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the y axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(yperiod=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "yperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the y axis.",
+          "dflt": "middle",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "start",
+            "middle",
+            "end"
+          ],
+          "magic_underscores": "fig.update_traces(yperiodalignment=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "yperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the y0 axis. When `y0period` is round number of weeks, the `y0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(yperiod0=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "marker": {
           "angle": {
@@ -35945,14 +33182,14 @@
             "dflt": 0,
             "editType": "calc",
             "valType": "angle",
-            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "color": {
             "arrayOk": false,
             "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "editType": "plot",
           "line": {
@@ -35962,14 +33199,14 @@
               "dflt": "#444",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "editType": "style",
             "outliercolor": {
               "description": "Sets the border line color of the outlier sample points. Defaults to marker.color",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_outliercolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
+              "magic_underscores": "fig.update_traces(marker_line_outliercolor=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "outlierwidth": {
               "description": "Sets the border line width (in px) of the outlier sample points.",
@@ -35977,7 +33214,7 @@
               "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_outlierwidth=&lt;VALUE&gt;, selector=dict(type='violin'))"
+              "magic_underscores": "fig.update_traces(marker_line_outlierwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "role": "object",
             "width": {
@@ -35987,9 +33224,9 @@
               "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='box'))"
           },
           "opacity": {
             "arrayOk": false,
@@ -35999,14 +33236,14 @@
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "outliercolor": {
             "description": "Sets the color of the outlier sample points.",
             "dflt": "rgba(0, 0, 0, 0)",
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_outliercolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(marker_outliercolor=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "role": "object",
           "size": {
@@ -36016,7 +33253,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "symbol": {
             "arrayOk": false,
@@ -36512,166 +33749,223 @@
               "154",
               "arrow-wide-open"
             ],
-            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='box'))"
         },
         "line": {
           "color": {
-            "description": "Sets the color of line bounding the violin(s).",
+            "description": "Sets the color of line bounding the box(es).",
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "editType": "plot",
           "role": "object",
           "width": {
-            "description": "Sets the width (in px) of line bounding the violin(s).",
+            "description": "Sets the width (in px) of line bounding the box(es).",
             "dflt": 2,
             "editType": "style",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='box'))"
         },
-        "box": {
-          "editType": "plot",
-          "fillcolor": {
-            "description": "Sets the inner box plot fill color.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(box_fillcolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "line": {
-            "color": {
-              "description": "Sets the inner box plot bounding line color.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(box_line_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "editType": "style",
-            "role": "object",
-            "width": {
-              "description": "Sets the inner box plot bounding line width.",
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(box_line_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "magic_underscores": "fig.update_traces(box_line=dict(...), selector=dict(type='violin'))"
-          },
-          "role": "object",
-          "visible": {
-            "description": "Determines if an miniature box plot is drawn inside the violins. ",
-            "dflt": false,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(box_visible=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "width": {
-            "description": "Sets the width of the inner box plots relative to the violins' width. For example, with 1, the inner box plots are as wide as the violins.",
-            "dflt": 0.25,
-            "editType": "plot",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(box_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "magic_underscores": "fig.update_traces(box=dict(...), selector=dict(type='violin'))"
+        "boxmean": {
+          "description": "If *true*, the mean of the box(es)' underlying distribution is drawn as a dashed line inside the box(es). If *sd* the standard deviation is also drawn. Defaults to *true* when `mean` is set. Defaults to *sd* when `sd` is set Otherwise defaults to *false*.",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            true,
+            "sd",
+            false
+          ],
+          "magic_underscores": "fig.update_traces(boxmean=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "quartilemethod": {
-          "description": "Sets the method used to compute the sample's Q1 and Q3 quartiles. The *linear* method uses the 25th percentile for Q1 and 75th percentile for Q3 as computed using method #10 (listed on http://jse.amstat.org/v14n3/langford.html). The *exclusive* method uses the median to divide the ordered dataset into two halves if the sample is odd, it does not include the median in either half - Q1 is then the median of the lower half and Q3 the median of the upper half. The *inclusive* method also uses the median to divide the ordered dataset into two halves but if the sample is odd, it includes the median in both halves - Q1 is then the median of the lower half and Q3 the median of the upper half.",
-          "dflt": "linear",
+        "boxpoints": {
+          "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the box(es) are shown with no sample points Defaults to *suspectedoutliers* when `marker.outliercolor` or `marker.line.outliercolor` is set. Defaults to *all* under the q1/median/q3 signature. Otherwise defaults to *outliers*.",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "linear",
-            "exclusive",
-            "inclusive"
+            "all",
+            "outliers",
+            "suspectedoutliers",
+            false
           ],
-          "magic_underscores": "fig.update_traces(quartilemethod=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(boxpoints=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+        "notched": {
+          "description": "Determines whether or not notches are drawn. Notches displays a confidence interval around the median. We compute the confidence interval as median +/- 1.57 * IQR / sqrt(N), where IQR is the interquartile range and N is the sample size. If two boxes' notches do not overlap there is 95% confidence their medians differ. See https://sites.google.com/site/davidsstatistics/home/notched-box-plots for more info. Defaults to *false* unless `notchwidth` or `notchspan` is set.",
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(notched=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "selected": {
-          "editType": "style",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of selected points.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "editType": "style",
-            "opacity": {
-              "description": "Sets the marker opacity of selected points.",
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "role": "object",
-            "size": {
-              "description": "Sets the marker size of selected points.",
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='violin'))"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='violin'))"
+        "notchwidth": {
+          "description": "Sets the width of the notches relative to the box width. For example, with 0, the notches are as wide as the box(es).",
+          "dflt": 0.25,
+          "editType": "calc",
+          "max": 0.5,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(notchwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "unselected": {
-          "editType": "style",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "editType": "style",
-            "opacity": {
-              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
+        "showwhiskers": {
+          "description": "Determines whether or not whiskers are visible. Defaults to true for `sizemode` *quartiles*, false for *sd*.",
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showwhiskers=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "whiskerwidth": {
+          "description": "Sets the width of the whiskers relative to the box width. For example, with 1, the whiskers are as wide as the box(es).",
+          "dflt": 0.5,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(whiskerwidth=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "q1": {
+          "description": "Sets the Quartile 1 values. There should be as many items as the number of boxes desired.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(q1=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "median": {
+          "description": "Sets the median values. There should be as many items as the number of boxes desired.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(median=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "q3": {
+          "description": "Sets the Quartile 3 values. There should be as many items as the number of boxes desired.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(q3=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "lowerfence": {
+          "description": "Sets the lower fence values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `lowerfence` is not provided but a sample (in `y` or `x`) is set, we compute the lower as the last sample point below 1.5 times the IQR.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(lowerfence=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "upperfence": {
+          "description": "Sets the upper fence values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `upperfence` is not provided but a sample (in `y` or `x`) is set, we compute the upper as the last sample point above 1.5 times the IQR.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(upperfence=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "notchspan": {
+          "description": "Sets the notch span from the boxes' `median` values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `notchspan` is not provided but a sample (in `y` or `x`) is set, we compute it as 1.57 * IQR / sqrt(N), where N is the sample size.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(notchspan=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "mean": {
+          "description": "Sets the mean values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `mean` is not provided but a sample (in `y` or `x`) is set, we compute the mean for each box using the sample values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(mean=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "sd": {
+          "description": "Sets the standard deviation values. There should be as many items as the number of boxes desired. This attribute has effect only under the q1/median/q3 signature. If `sd` is not provided but a sample (in `y` or `x`) is set, we compute the standard deviation for each box using the sample values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(sd=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "sdmultiple": {
+          "description": "Scales the box size when sizemode=sd Allowing boxes to be drawn across any stddev range For example 1-stddev, 3-stddev, 5-stddev",
+          "dflt": 1,
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(sdmultiple=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "quartilemethod": {
+          "description": "Sets the method used to compute the sample's Q1 and Q3 quartiles. The *linear* method uses the 25th percentile for Q1 and 75th percentile for Q3 as computed using method #10 (listed on http://jse.amstat.org/v14n3/langford.html). The *exclusive* method uses the median to divide the ordered dataset into two halves if the sample is odd, it does not include the median in either half - Q1 is then the median of the lower half and Q3 the median of the upper half. The *inclusive* method also uses the median to divide the ordered dataset into two halves but if the sample is odd, it includes the median in both halves - Q1 is then the median of the lower half and Q3 the median of the upper half.",
+          "dflt": "linear",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "linear",
+            "exclusive",
+            "inclusive"
+          ],
+          "magic_underscores": "fig.update_traces(quartilemethod=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='box'))"
+        },
+        "selected": {
+          "editType": "style",
+          "marker": {
+            "color": {
+              "description": "Sets the marker color of selected points.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='box'))"
+            },
+            "editType": "style",
+            "opacity": {
+              "description": "Sets the marker opacity of selected points.",
               "editType": "style",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
+              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "role": "object",
             "size": {
-              "description": "Sets the marker size of unselected points, applied only when a selection exists.",
+              "description": "Sets the marker size of selected points.",
               "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
+              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='box'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='box'))"
         },
-        "bandwidth": {
-          "description": "Sets the bandwidth used to compute the kernel density estimate. By default, the bandwidth is determined by Silverman's rule of thumb.",
-          "editType": "calc",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(bandwidth=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        "unselected": {
+          "editType": "style",
+          "marker": {
+            "color": {
+              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='box'))"
+            },
+            "editType": "style",
+            "opacity": {
+              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
+              "editType": "style",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='box'))"
+            },
+            "role": "object",
+            "size": {
+              "description": "Sets the marker size of unselected points, applied only when a selection exists.",
+              "editType": "style",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='box'))"
+            },
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='box'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='box'))"
         },
         "fillcolor": {
           "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
           "editType": "style",
           "valType": "color",
-          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "hoverlabel": {
           "align": {
@@ -36685,36 +33979,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "editType": "none",
           "font": {
@@ -36722,12 +34001,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -36738,12 +34012,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -36759,12 +34028,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "role": "object",
             "shadow": {
@@ -36773,24 +34037,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "style": {
               "arrayOk": true,
@@ -36802,12 +34056,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -36821,12 +34070,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "variant": {
               "arrayOk": true,
@@ -36842,12 +34086,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
             "weight": {
               "arrayOk": true,
@@ -36861,14 +34100,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='violin'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='box'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='box'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -36877,12 +34111,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
           "role": "object",
           "showarrow": {
@@ -36890,165 +34119,105 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='box'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='box'))"
         },
         "hoveron": {
-          "description": "Do the hover effects highlight individual violins or sample points or the kernel density estimate or any combination of them?",
-          "dflt": "violins+points+kde",
+          "description": "Do the hover effects highlight individual boxes or sample points or both?",
+          "dflt": "boxes+points",
           "editType": "style",
-          "extras": [
-            "all"
-          ],
           "flags": [
-            "violins",
-            "points",
-            "kde"
+            "boxes",
+            "points"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoveron=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(hoveron=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "pointpos": {
-          "description": "Sets the position of the sample points in relation to the violins. If *0*, the sample points are places over the center of the violins. Positive (negative) values correspond to positions to the right (left) for vertical violins and above (below) for horizontal violins.",
+          "description": "Sets the position of the sample points in relation to the box(es). If *0*, the sample points are places over the center of the box(es). Positive (negative) values correspond to positions to the right (left) for vertical boxes and above (below) for horizontal boxes",
           "editType": "calc",
           "max": 2,
           "min": -2,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(pointpos=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(pointpos=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "jitter": {
-          "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the violins.",
+          "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the box(es).",
           "editType": "calc",
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(jitter=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "meanline": {
-          "color": {
-            "description": "Sets the mean line color.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(meanline_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "editType": "plot",
-          "role": "object",
-          "visible": {
-            "description": "Determines if a line corresponding to the sample's mean is shown inside the violins. If `box.visible` is turned on, the mean line is drawn inside the inner box. Otherwise, the mean line is drawn from one side of the violin to other.",
-            "dflt": false,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(meanline_visible=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "width": {
-            "description": "Sets the mean line width.",
-            "editType": "style",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(meanline_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "magic_underscores": "fig.update_traces(meanline=dict(...), selector=dict(type='violin'))"
-        },
-        "points": {
-          "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the violins are shown with no sample points. Defaults to *suspectedoutliers* when `marker.outliercolor` or `marker.line.outliercolor` is set, otherwise defaults to *outliers*.",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "all",
-            "outliers",
-            "suspectedoutliers",
-            false
-          ],
-          "magic_underscores": "fig.update_traces(points=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "scalegroup": {
-          "description": "If there are multiple violins that should be sized according to to some metric (see `scalemode`), link them by providing a non-empty group id here shared by every trace in the same group. If a violin's `width` is undefined, `scalegroup` will default to the trace's name. In this case, violins with the same names will be linked together",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(scalegroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(jitter=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "scalemode": {
-          "description": "Sets the metric by which the width of each violin is determined. *width* means each violin has the same (max) width *count* means the violins are scaled by the number of sample points making up each violin.",
-          "dflt": "width",
+        "sizemode": {
+          "description": "Sets the upper and lower bound for the boxes quartiles means box is drawn between Q1 and Q3 SD means the box is drawn between Mean +- Standard Deviation Argument sdmultiple (default 1) to scale the box size So it could be drawn 1-stddev, 3-stddev etc",
+          "dflt": "quartiles",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "width",
-            "count"
+            "quartiles",
+            "sd"
           ],
-          "magic_underscores": "fig.update_traces(scalemode=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(sizemode=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "side": {
-          "description": "Determines on which side of the position value the density function making up one half of a violin is plotted. Useful when comparing two violin traces under *overlay* mode, where one trace has `side` set to *positive* and the other to *negative*.",
-          "dflt": "both",
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "both",
-            "positive",
-            "negative"
-          ],
-          "magic_underscores": "fig.update_traces(side=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "span": {
-          "description": "Sets the span in data space for which the density function will be computed. Has an effect only when `spanmode` is set to *manual*.",
-          "editType": "calc",
-          "items": [
-            {
-              "editType": "calc",
-              "valType": "any"
-            },
-            {
-              "editType": "calc",
-              "valType": "any"
-            }
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
           ],
-          "valType": "info_array",
-          "magic_underscores": "fig.update_traces(span=list(...), selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "spanmode": {
-          "description": "Sets the method by which the span in data space where the density function will be computed. *soft* means the span goes from the sample's minimum value minus two bandwidths to the sample's maximum value plus two bandwidths. *hard* means the span goes from the sample's minimum to its maximum value. For custom span settings, use mode *manual* and fill in the `span` attribute.",
-          "dflt": "soft",
+        "ycalendar": {
+          "description": "Sets the calendar system to use with `y` date data.",
+          "dflt": "gregorian",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "soft",
-            "hard",
-            "manual"
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
           ],
-          "magic_underscores": "fig.update_traces(spanmode=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='violin'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='violin'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='violin'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='box'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='violin'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='box'))"
       },
       "categories": [
         "cartesian",
@@ -37057,28 +34226,28 @@
         "oriented",
         "box-violin",
         "showLegend",
-        "violinLayout",
+        "boxLayout",
         "zoomScale"
       ],
       "layoutAttributes": {
-        "violingap": {
-          "description": "Sets the gap (in plot fraction) between violins of adjacent location coordinates. Has no effect on traces that have *width* set.",
+        "boxgap": {
+          "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates. Has no effect on traces that have *width* set.",
           "dflt": 0.3,
           "editType": "calc",
           "max": 1,
           "min": 0,
           "valType": "number"
         },
-        "violingroupgap": {
-          "description": "Sets the gap (in plot fraction) between violins of the same location coordinate. Has no effect on traces that have *width* set.",
+        "boxgroupgap": {
+          "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate. Has no effect on traces that have *width* set.",
           "dflt": 0.3,
           "editType": "calc",
           "max": 1,
           "min": 0,
           "valType": "number"
         },
-        "violinmode": {
-          "description": "Determines how violins at the same location coordinate are displayed on the graph. If *group*, the violins are plotted next to one another centered around the shared location. If *overlay*, the violins are plotted over one another, you might need to set *opacity* to see them multiple violins. Has no effect on traces that have *width* set.",
+        "boxmode": {
+          "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes. Has no effect on traces that have *width* set.",
           "dflt": "overlay",
           "editType": "calc",
           "valType": "enumerated",
@@ -37089,25 +34258,25 @@
         }
       },
       "meta": {
-        "description": "In vertical (horizontal) violin plots, statistics are computed using `y` (`x`) values. By supplying an `x` (`y`) array, one violin per distinct x (y) value is drawn If no `x` (`y`) {array} is provided, a single violin is drawn. That violin position is then positioned with with `name` or with `x0` (`y0`) if provided."
+        "description": "Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The second quartile (Q2, i.e. the median) is marked by a line inside the box. The fences grow outward from the boxes' edges, by default they span +/- 1.5 times the interquartile range (IQR: Q3-Q1), The sample mean and standard deviation as well as notches and the sample, outlier and suspected outliers points can be optionally added to the box plot. The values and positions corresponding to each boxes can be input using two signatures. The first signature expects users to supply the sample values in the `y` data array for vertical boxes (`x` for horizontal boxes). By supplying an `x` (`y`) array, one box per distinct `x` (`y`) value is drawn If no `x` (`y`) {array} is provided, a single box is drawn. In this case, the box is positioned with the trace `name` or with `x0` (`y0`) if provided. The second signature expects users to supply the boxes corresponding Q1, median and Q3 statistics in the `q1`, `median` and `q3` data arrays respectively. Other box features relying on statistics namely `lowerfence`, `upperfence`, `notchspan` can be set directly by the users. To have plotly compute them or to show sample points besides the boxes, users can set the `y` data array for vertical boxes (`x` for horizontal boxes) to a 2D array with the outer length corresponding to the number of boxes in the traces and the inner length corresponding the sample size."
       },
-      "type": "violin"
+      "type": "box"
     },
-    "histogram": {
+    "violin": {
       "animatable": false,
       "attributes": {
-        "type": "histogram",
+        "type": "violin",
         "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover. For violin traces, the name will also be used for the position coordinate, if `x` and `x0` (`y` and `y0` if horizontal) are missing and the position axis is categorical. Note that the trace name is also used as a default value for attribute `scalegroup` (please see its description for details).",
+          "editType": "calc+clearAxisTypes",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -37119,35 +34288,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": true,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -37155,7 +34324,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -37165,7 +34334,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -37180,7 +34349,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "role": "object",
             "shadow": {
@@ -37188,13 +34357,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -37205,7 +34374,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -37218,7 +34387,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -37233,7 +34402,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -37246,9 +34415,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='histogram'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='violin'))"
           },
           "role": "object",
           "text": {
@@ -37256,16 +34425,16 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='violin'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "opacity": {
           "description": "Sets the opacity of the trace.",
@@ -37274,105 +34443,72 @@
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
           "editType": "plot",
           "valType": "integer",
-          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "x": {
-          "description": "Sets the sample data to be binned on the x axis.",
+          "description": "Sets the x sample data or coordinates. See overview for more info.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
+        "x0": {
+          "description": "Sets the x coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "y": {
-          "description": "Sets the sample data to be binned on the y axis.",
+          "description": "Sets the y sample data or coordinates. See overview for more info.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
+        "y0": {
+          "description": "Sets the y coordinate for single-box traces or the starting coordinate for multi-box traces set using q1/median/q3. See overview for more info.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "width": {
+          "description": "Sets the width of the violin in data coordinates. If *0* (default value) the width is automatically selected based on the positions of other violin traces in the same subplot.",
+          "dflt": 0,
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets hover text elements associated with each bar. If a single string, the same string appears over all bars. If an array of string, the items are mapped in order to the this trace's coordinates.",
+          "description": "Sets the text elements associated with each sample value. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "textposition": {
-          "arrayOk": false,
-          "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed), unless there is another bar stacked on this one, then the text gets pushed inside. *auto* tries to position `text` inside the bar, but if the bar is too small and no bar is stacked on this one the text is moved outside. If *none*, no text appears.",
-          "dflt": "auto",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "inside",
-            "outside",
-            "auto",
-            "none"
-          ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
-        "texttemplate": {
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label` and `value`.",
+        "hovertext": {
+          "arrayOk": true,
+          "description": "Same as `text`.",
           "dflt": "",
-          "editType": "plot",
+          "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "texttemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Same as `text`.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -37388,6411 +34524,822 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `binNumber` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "yaxis": {
           "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
           "dflt": "y",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "orientation": {
-          "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal).",
+          "description": "Sets the orientation of the violin(s). If *v* (*h*), the distribution is visualized along the vertical (horizontal).",
           "editType": "calc+clearAxisTypes",
           "valType": "enumerated",
           "values": [
             "v",
             "h"
           ],
-          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "histfunc": {
-          "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.",
-          "dflt": "count",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "count",
-            "sum",
-            "avg",
-            "min",
-            "max"
-          ],
-          "magic_underscores": "fig.update_traces(histfunc=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "histnorm": {
-          "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "",
-            "percent",
-            "probability",
-            "density",
-            "probability density"
-          ],
-          "magic_underscores": "fig.update_traces(histnorm=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "alignmentgroup": {
           "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "offsetgroup": {
           "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "nbinsx": {
-          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `xbins.size` is provided.",
-          "dflt": 0,
-          "editType": "calc",
-          "min": 0,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(nbinsx=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "nbinsy": {
-          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `ybins.size` is provided.",
-          "dflt": 0,
-          "editType": "calc",
-          "min": 0,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(nbinsy=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "autobinx": {
-          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobinx` is not needed. However, we accept `autobinx: true` or `false` and will update `xbins` accordingly before deleting `autobinx` from the trace.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autobinx=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "autobiny": {
-          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobiny` is not needed. However, we accept `autobiny: true` or `false` and will update `ybins` accordingly before deleting `autobiny` from the trace.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autobiny=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "bingroup": {
-          "description": "Set a group of histogram traces which will have compatible bin settings. Note that traces on the same subplot and with the same *orientation* under `barmode` *stack*, *relative* and *group* are forced into the same bingroup, Using `bingroup`, traces under `barmode` *overlay* and on different axes (of the same axis type) can have compatible bin settings. Note that histogram and histogram2d* trace can share the same `bingroup`",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(bingroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "xbins": {
-          "editType": "calc",
-          "end": {
-            "description": "Sets the end value for the x axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_end=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "size": {
-            "description": "Sets the size of each x axis bin. Default behavior: If `nbinsx` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsx` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). If multiple non-overlaying histograms share a subplot, the first explicit `size` is used and all others discarded. If no `size` is provided,the sample data from all traces is combined to determine `size` as described above.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "start": {
-            "description": "Sets the starting value for the x axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. If multiple non-overlaying histograms share a subplot, the first explicit `start` is used exactly and all others are shifted down (if necessary) to differ from that one by an integer number of bins.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_start=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(xbins=dict(...), selector=dict(type='histogram'))"
-        },
-        "ybins": {
-          "editType": "calc",
-          "end": {
-            "description": "Sets the end value for the y axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_end=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "size": {
-            "description": "Sets the size of each y axis bin. Default behavior: If `nbinsy` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsy` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). If multiple non-overlaying histograms share a subplot, the first explicit `size` is used and all others discarded. If no `size` is provided,the sample data from all traces is combined to determine `size` as described above.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "start": {
-            "description": "Sets the starting value for the y axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. If multiple non-overlaying histograms share a subplot, the first explicit `start` is used exactly and all others are shifted down (if necessary) to differ from that one by an integer number of bins.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_start=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(ybins=dict(...), selector=dict(type='histogram'))"
+          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "marker": {
-          "autocolorscale": {
-            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-            "dflt": true,
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "cauto": {
-            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
-            "dflt": true,
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "cmax": {
-            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
-            "dflt": null,
-            "editType": "plot",
-            "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "cmid": {
-            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
-            "dflt": null,
+          "angle": {
+            "arrayOk": false,
+            "description": "Sets the marker angle in respect to `angleref`.",
+            "dflt": 0,
             "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "cmin": {
-            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
-            "dflt": null,
-            "editType": "plot",
-            "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            "valType": "angle",
+            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
           "color": {
-            "arrayOk": true,
+            "arrayOk": false,
             "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "coloraxis": {
-            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-            "dflt": null,
-            "editType": "calc",
-            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-            "valType": "subplotid",
-            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "colorbar": {
-            "bgcolor": {
-              "description": "Sets the color of padded area.",
-              "dflt": "rgba(0,0,0,0)",
-              "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "bordercolor": {
-              "description": "Sets the axis line color.",
+          "editType": "plot",
+          "line": {
+            "color": {
+              "arrayOk": false,
+              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
               "dflt": "#444",
-              "editType": "colorbars",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "borderwidth": {
-              "description": "Sets the width (in px) or the border enclosing this color bar.",
-              "dflt": 0,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "dtick": {
-              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-              "editType": "colorbars",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "editType": "colorbars",
-            "exponentformat": {
-              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-              "dflt": "B",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "none",
-                "e",
-                "E",
-                "power",
-                "SI",
-                "B",
-                "SI extended"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "labelalias": {
-              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-              "dflt": false,
-              "editType": "colorbars",
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "len": {
-              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-              "dflt": 1,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "lenmode": {
-              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-              "dflt": "fraction",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "minexponent": {
-              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-              "dflt": 3,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "nticks": {
-              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-              "dflt": 0,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "orientation": {
-              "description": "Sets the orientation of the colorbar.",
-              "dflt": "v",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "h",
-                "v"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "outlinecolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
-              "editType": "colorbars",
+            "editType": "style",
+            "outliercolor": {
+              "description": "Sets the border line color of the outlier sample points. Defaults to marker.color",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(marker_line_outliercolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "outlinewidth": {
-              "description": "Sets the width (in px) of the axis line.",
+            "outlierwidth": {
+              "description": "Sets the border line width (in px) of the outlier sample points.",
               "dflt": 1,
-              "editType": "colorbars",
+              "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(marker_line_outlierwidth=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "role": "object",
-            "separatethousands": {
-              "description": "If \"true\", even 4-digit integers are separated",
-              "dflt": false,
-              "editType": "colorbars",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "showexponent": {
-              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-              "dflt": "all",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
-                "none"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "showticklabels": {
-              "description": "Determines whether or not the tick labels are drawn.",
-              "dflt": true,
-              "editType": "colorbars",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "showtickprefix": {
-              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-              "dflt": "all",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
-                "none"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "showticksuffix": {
-              "description": "Same as `showtickprefix` but for tick suffixes.",
-              "dflt": "all",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
-                "none"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "thickness": {
-              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-              "dflt": 30,
-              "editType": "colorbars",
+            "width": {
+              "arrayOk": false,
+              "description": "Sets the width (in px) of the lines bounding the marker points.",
+              "dflt": 0,
+              "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "thicknessmode": {
-              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-              "dflt": "pixels",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "tick0": {
-              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-              "editType": "colorbars",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "tickangle": {
-              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-              "dflt": "auto",
-              "editType": "colorbars",
-              "valType": "angle",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "tickcolor": {
-              "description": "Sets the tick color.",
-              "dflt": "#444",
-              "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "tickfont": {
-              "color": {
-                "editType": "colorbars",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "description": "Sets the color bar's tick label font",
-              "editType": "colorbars",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "size": {
-                "editType": "colorbars",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='histogram'))"
-            },
-            "tickformat": {
-              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "tickformatstops": {
-              "items": {
-                "tickformatstop": {
-                  "dtickrange": {
-                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                    "editType": "colorbars",
-                    "items": [
-                      {
-                        "editType": "colorbars",
-                        "valType": "any"
-                      },
-                      {
-                        "editType": "colorbars",
-                        "valType": "any"
-                      }
-                    ],
-                    "valType": "info_array"
-                  },
-                  "editType": "colorbars",
-                  "enabled": {
-                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                    "dflt": true,
-                    "editType": "colorbars",
-                    "valType": "boolean"
-                  },
-                  "name": {
-                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                    "editType": "colorbars",
-                    "valType": "string"
-                  },
-                  "role": "object",
-                  "templateitemname": {
-                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                    "editType": "colorbars",
-                    "valType": "string"
-                  },
-                  "value": {
-                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                    "dflt": "",
-                    "editType": "colorbars",
-                    "valType": "string"
-                  }
-                }
-              },
-              "role": "object",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='histogram'))"
-            },
-            "ticklabeloverflow": {
-              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "allow",
-                "hide past div",
-                "hide past domain"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ticklabelposition": {
-              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-              "dflt": "outside",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                "outside top",
-                "inside top",
-                "outside left",
-                "inside left",
-                "outside right",
-                "inside right",
-                "outside bottom",
-                "inside bottom"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ticklabelstep": {
-              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-              "dflt": 1,
-              "editType": "colorbars",
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ticklen": {
-              "description": "Sets the tick length (in px).",
-              "dflt": 5,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "tickmode": {
-              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-              "editType": "colorbars",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "enumerated",
-              "values": [
-                "auto",
-                "linear",
-                "array"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "tickprefix": {
-              "description": "Sets a tick label prefix.",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ticks": {
-              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                ""
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ticksuffix": {
-              "description": "Sets a tick label suffix.",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ticktext": {
-              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-              "editType": "colorbars",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickvals": {
-              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-              "editType": "colorbars",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickwidth": {
-              "description": "Sets the tick width (in px).",
-              "dflt": 1,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "title": {
-              "editType": "colorbars",
-              "font": {
-                "color": {
-                  "editType": "colorbars",
-                  "valType": "color",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "description": "Sets this color bar's title font.",
-                "editType": "colorbars",
-                "family": {
-                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                  "editType": "colorbars",
-                  "noBlank": true,
-                  "strict": true,
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "lineposition": {
-                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                  "dflt": "none",
-                  "editType": "colorbars",
-                  "extras": [
-                    "none"
-                  ],
-                  "flags": [
-                    "under",
-                    "over",
-                    "through"
-                  ],
-                  "valType": "flaglist",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "role": "object",
-                "shadow": {
-                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                  "dflt": "none",
-                  "editType": "colorbars",
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "size": {
-                  "editType": "colorbars",
-                  "min": 1,
-                  "valType": "number",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "style": {
-                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "italic"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "textcase": {
-                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "word caps",
-                    "upper",
-                    "lower"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "variant": {
-                  "description": "Sets the variant of the font.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "small-caps",
-                    "all-small-caps",
-                    "all-petite-caps",
-                    "petite-caps",
-                    "unicase"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "weight": {
-                  "description": "Sets the weight (or boldness) of the font.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "extras": [
-                    "normal",
-                    "bold"
-                  ],
-                  "max": 1000,
-                  "min": 1,
-                  "valType": "integer",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-                },
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='histogram'))"
-              },
-              "role": "object",
-              "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "right",
-                  "top",
-                  "bottom"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "text": {
-                "description": "Sets the title of the color bar.",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='histogram'))"
-            },
-            "x": {
-              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-              "editType": "colorbars",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "xanchor": {
-              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "left",
-                "center",
-                "right"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "xpad": {
-              "description": "Sets the amount of padding (in px) along the x direction.",
-              "dflt": 10,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "xref": {
-              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-              "dflt": "paper",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "y": {
-              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-              "editType": "colorbars",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "yanchor": {
-              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "top",
-                "middle",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "ypad": {
-              "description": "Sets the amount of padding (in px) along the y direction.",
-              "dflt": 10,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "yref": {
-              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-              "dflt": "paper",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='histogram'))"
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='violin'))"
           },
-          "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "autocolorscale": false,
-              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "valType": "colorscale",
-            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          "opacity": {
+            "arrayOk": false,
+            "description": "Sets the marker opacity.",
+            "dflt": 1,
+            "editType": "style",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+          "outliercolor": {
+            "description": "Sets the color of the outlier sample points.",
+            "dflt": "rgba(0, 0, 0, 0)",
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(marker_outliercolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "cornerradius": {
-            "description": "Sets the rounding of corners. May be an integer number of pixels, or a percentage of bar width (as a string ending in %). Defaults to `layout.barcornerradius`. In stack or relative barmode, the first trace to set cornerradius is used for the whole stack.",
+          "role": "object",
+          "size": {
+            "arrayOk": false,
+            "description": "Sets the marker size (in px).",
+            "dflt": 6,
             "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(marker_cornerradius=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "editType": "calc",
-          "line": {
-            "autocolorscale": {
-              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "cauto": {
-              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "cmax": {
-              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
-              "dflt": null,
-              "editType": "plot",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "cmid": {
-              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "cmin": {
-              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
-              "dflt": null,
-              "editType": "plot",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "coloraxis": {
-              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-              "dflt": null,
-              "editType": "calc",
-              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-              "valType": "subplotid",
-              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "autocolorscale": false,
-                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-              },
-              "valType": "colorscale",
-              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "editType": "calc",
-            "reversescale": {
-              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
-              "dflt": false,
-              "editType": "plot",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "role": "object",
-            "width": {
-              "arrayOk": true,
-              "description": "Sets the width (in px) of the lines bounding the marker points.",
-              "dflt": 0,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='histogram'))"
-          },
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the opacity of the bars.",
-            "dflt": 1,
-            "editType": "style",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "pattern": {
-            "bgcolor": {
-              "arrayOk": true,
-              "description": "When there is no colorscale sets the color of background pattern fill. Defaults to a `marker.color` background when `fillmode` is *overlay*. Otherwise, defaults to a transparent background.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "description": "Sets the pattern within the marker.",
-            "editType": "style",
-            "fgcolor": {
-              "arrayOk": true,
-              "description": "When there is no colorscale sets the color of foreground pattern fill. Defaults to a `marker.color` background when `fillmode` is *replace*. Otherwise, defaults to dark grey or white to increase contrast with the `bgcolor`.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "fgopacity": {
-              "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_pattern_fgopacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "fillmode": {
-              "description": "Determines whether `marker.color` should be used as a default to `bgcolor` or a `fgcolor`.",
-              "dflt": "replace",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "replace",
-                "overlay"
-              ],
-              "magic_underscores": "fig.update_traces(marker_pattern_fillmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "path": {
-              "arrayOk": true,
-              "description": "Sets a custom path for pattern fill. Use with no `shape` or `solidity`, provide an SVG path string for the regions of the square from (0,0) to (`size`,`size`) to color.",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "shape": {
-              "arrayOk": true,
-              "description": "Sets the shape of the pattern fill. By default, no pattern is used for filling the area.",
-              "dflt": "",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "",
-                "/",
-                "\\",
-                "x",
-                "-",
-                "|",
-                "+",
-                "."
-              ],
-              "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "size": {
-              "arrayOk": true,
-              "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
-              "dflt": 8,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "solidity": {
-              "arrayOk": true,
-              "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
-              "dflt": 0.3,
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='histogram'))"
-          },
-          "reversescale": {
-            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
-            "dflt": false,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "showscale": {
-            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='histogram'))"
-        },
-        "textangle": {
-          "description": "Sets the angle of the tick labels with respect to the bar. For example, a `tickangle` of -90 draws the tick labels vertically. With *auto* the texts may automatically be rotated to fit with the maximum size in bars.",
-          "dflt": "auto",
-          "editType": "plot",
-          "valType": "angle",
-          "magic_underscores": "fig.update_traces(textangle=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "textfont": {
-          "color": {
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "description": "Sets the text font.",
-          "editType": "plot",
-          "family": {
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "plot",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "lineposition": {
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "plot",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "shadow": {
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "size": {
-            "editType": "plot",
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "style": {
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "italic"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "textcase": {
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "variant": {
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "weight": {
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='histogram'))"
-        },
-        "error_x": {
-          "array": {
-            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_x_array=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "arrayminus": {
-            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_x_arrayminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "color": {
-            "description": "Sets the stroke color of the error bars.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(error_x_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "copy_ystyle": {
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_x_copy_ystyle=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "editType": "calc",
-          "role": "object",
-          "symmetric": {
-            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_x_symmetric=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness (in px) of the error bars.",
-            "dflt": 2,
-            "editType": "style",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_thickness=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "traceref": {
-            "dflt": 0,
-            "editType": "style",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_x_traceref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "tracerefminus": {
-            "dflt": 0,
-            "editType": "style",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_x_tracerefminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "type": {
-            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "percent",
-              "constant",
-              "sqrt",
-              "data"
-            ],
-            "magic_underscores": "fig.update_traces(error_x_type=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "value": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_value=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "valueminus": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_valueminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "visible": {
-            "description": "Determines whether or not this set of error bars is visible.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_x_visible=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "width": {
-            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
+          "symbol": {
+            "arrayOk": false,
+            "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
+            "dflt": "circle",
             "editType": "plot",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_width=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(error_x=dict(...), selector=dict(type='histogram'))"
-        },
-        "error_y": {
-          "array": {
-            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_y_array=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "arrayminus": {
-            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_y_arrayminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "color": {
-            "description": "Sets the stroke color of the error bars.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(error_y_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "editType": "calc",
-          "role": "object",
-          "symmetric": {
-            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_y_symmetric=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness (in px) of the error bars.",
-            "dflt": 2,
-            "editType": "style",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_thickness=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "traceref": {
-            "dflt": 0,
-            "editType": "style",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_y_traceref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "tracerefminus": {
-            "dflt": 0,
-            "editType": "style",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_y_tracerefminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "type": {
-            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
-            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "percent",
-              "constant",
-              "sqrt",
-              "data"
-            ],
-            "magic_underscores": "fig.update_traces(error_y_type=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "value": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_value=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "valueminus": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_valueminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "visible": {
-            "description": "Determines whether or not this set of error bars is visible.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_y_visible=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "width": {
-            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
-            "editType": "plot",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_width=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(error_y=dict(...), selector=dict(type='histogram'))"
-        },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "selected": {
-          "editType": "style",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of selected points.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "editType": "style",
-            "opacity": {
-              "description": "Sets the marker opacity of selected points.",
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "textfont": {
-            "color": {
-              "description": "Sets the text font color of selected points.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "editType": "style",
-            "role": "object",
-            "magic_underscores": "fig.update_traces(selected_textfont=dict(...), selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='histogram'))"
-        },
-        "unselected": {
-          "editType": "style",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "editType": "style",
-            "opacity": {
-              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "textfont": {
-            "color": {
-              "description": "Sets the text font color of unselected points, applied only when a selection exists.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "editType": "style",
-            "role": "object",
-            "magic_underscores": "fig.update_traces(unselected_textfont=dict(...), selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='histogram'))"
-        },
-        "cliponaxis": {
-          "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.",
-          "dflt": true,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cliponaxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "constraintext": {
-          "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself.",
-          "dflt": "both",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "inside",
-            "outside",
-            "both",
-            "none"
-          ],
-          "magic_underscores": "fig.update_traces(constraintext=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "cumulative": {
-          "currentbin": {
-            "description": "Only applies if cumulative is enabled. Sets whether the current bin is included, excluded, or has half of its value included in the current cumulative value. *include* is the default for compatibility with various other tools, however it introduces a half-bin bias to the results. *exclude* makes the opposite half-bin bias, and *half* removes it.",
-            "dflt": "include",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "include",
-              "exclude",
-              "half"
-            ],
-            "magic_underscores": "fig.update_traces(cumulative_currentbin=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "direction": {
-            "description": "Only applies if cumulative is enabled. If *increasing* (default) we sum all prior bins, so the result increases from left to right. If *decreasing* we sum later bins so the result decreases from left to right.",
-            "dflt": "increasing",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "increasing",
-              "decreasing"
-            ],
-            "magic_underscores": "fig.update_traces(cumulative_direction=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "editType": "calc",
-          "enabled": {
-            "description": "If true, display the cumulative distribution by summing the binned values. Use the `direction` and `centralbin` attributes to tune the accumulation method. Note: in this mode, the *density* `histnorm` settings behave the same as their equivalents without *density*: ** and *density* both rise to the number of data points, and *probability* and *probability density* both rise to the number of sample points.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(cumulative_enabled=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(cumulative=dict(...), selector=dict(type='histogram'))"
-        },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "right",
-              "auto"
-            ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bordercolor": {
-            "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "none",
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "none",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "none",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "none",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "size": {
-              "arrayOk": true,
-              "editType": "none",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='histogram'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='histogram'))"
-        },
-        "insidetextanchor": {
-          "description": "Determines if texts are kept at center or start/end points in `textposition` *inside* mode.",
-          "dflt": "end",
-          "editType": "plot",
-          "valType": "enumerated",
-          "values": [
-            "end",
-            "middle",
-            "start"
-          ],
-          "magic_underscores": "fig.update_traces(insidetextanchor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "insidetextfont": {
-          "color": {
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "description": "Sets the font used for `text` lying inside the bar.",
-          "editType": "plot",
-          "family": {
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "plot",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "lineposition": {
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "plot",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "shadow": {
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "size": {
-            "editType": "plot",
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "style": {
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "italic"
-            ],
-            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "textcase": {
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "variant": {
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "weight": {
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='histogram'))"
-        },
-        "outsidetextfont": {
-          "color": {
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "description": "Sets the font used for `text` lying outside the bar.",
-          "editType": "plot",
-          "family": {
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "plot",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "lineposition": {
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "plot",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "shadow": {
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "size": {
-            "editType": "plot",
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "style": {
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "italic"
-            ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "textcase": {
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "variant": {
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "weight": {
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='histogram'))"
-        },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "ycalendar": {
-          "description": "Sets the calendar system to use with `y` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='histogram'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='histogram'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='histogram'))"
-      },
-      "categories": [
-        "bar-like",
-        "cartesian",
-        "svg",
-        "bar",
-        "histogram",
-        "oriented",
-        "errorBarsOK",
-        "showLegend"
-      ],
-      "layoutAttributes": {
-        "barcornerradius": {
-          "description": "Sets the rounding of bar corners. May be an integer number of pixels, or a percentage of bar width (as a string ending in %).",
-          "editType": "calc",
-          "valType": "any"
-        },
-        "bargap": {
-          "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates.",
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
-        },
-        "bargroupgap": {
-          "description": "Sets the gap (in plot fraction) between bars of the same location coordinate.",
-          "dflt": 0,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
-        },
-        "barmode": {
-          "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *relative*, the bars are stacked on top of one another, with negative values below the axis, positive values above With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to reduce *opacity* to see multiple bars.",
-          "dflt": "group",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "stack",
-            "group",
-            "overlay",
-            "relative"
-          ]
-        },
-        "barnorm": {
-          "description": "Sets the normalization for bar traces on the graph. With *fraction*, the value of each bar is divided by the sum of all values at that location coordinate. *percent* is the same but multiplied by 100 to show percentages.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "",
-            "fraction",
-            "percent"
-          ]
-        }
-      },
-      "meta": {
-        "description": "The sample data from which statistics are computed is set in `x` for vertically spanning histograms and in `y` for horizontally spanning histograms. Binning options are set `xbins` and `ybins` respectively if no aggregation data is provided."
-      },
-      "type": "histogram"
-    },
-    "histogram2d": {
-      "animatable": false,
-      "attributes": {
-        "type": "histogram2d",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": false,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "size": {
-              "editType": "style",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='histogram2d'))"
-          },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x": {
-          "description": "Sets the sample data to be binned on the x axis.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xgap": {
-          "description": "Sets the horizontal gap (in pixels) between bricks.",
-          "dflt": 0,
-          "editType": "plot",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(xgap=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "y": {
-          "description": "Sets the sample data to be binned on the y axis.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "ygap": {
-          "description": "Sets the vertical gap (in pixels) between bricks.",
-          "dflt": 0,
-          "editType": "plot",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(ygap=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "z": {
-          "description": "Sets the aggregation data.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "texttemplate": {
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `z`",
-          "dflt": "",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "texttemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
-          "editType": "none",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "x",
-            "y",
-            "z",
-            "text",
-            "name"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `z` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xaxis": {
-          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
-          "dflt": "x",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "yaxis": {
-          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
-          "dflt": "y",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "coloraxis": {
-          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-          "dflt": null,
-          "editType": "calc",
-          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "histfunc": {
-          "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.",
-          "dflt": "count",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "count",
-            "sum",
-            "avg",
-            "min",
-            "max"
-          ],
-          "magic_underscores": "fig.update_traces(histfunc=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "histnorm": {
-          "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "",
-            "percent",
-            "probability",
-            "density",
-            "probability density"
-          ],
-          "magic_underscores": "fig.update_traces(histnorm=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "nbinsx": {
-          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `xbins.size` is provided.",
-          "dflt": 0,
-          "editType": "calc",
-          "min": 0,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(nbinsx=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "nbinsy": {
-          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `ybins.size` is provided.",
-          "dflt": 0,
-          "editType": "calc",
-          "min": 0,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(nbinsy=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "autobinx": {
-          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobinx` is not needed. However, we accept `autobinx: true` or `false` and will update `xbins` accordingly before deleting `autobinx` from the trace.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autobinx=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "autobiny": {
-          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobiny` is not needed. However, we accept `autobiny: true` or `false` and will update `ybins` accordingly before deleting `autobiny` from the trace.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autobiny=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "bingroup": {
-          "description": "Set the `xbingroup` and `ybingroup` default prefix For example, setting a `bingroup` of *1* on two histogram2d traces will make them their x-bins and y-bins match separately.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(bingroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "xbingroup": {
-          "description": "Set a group of histogram traces which will have compatible x-bin settings. Using `xbingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible x-bin settings. Note that the same `xbingroup` value can be used to set (1D) histogram `bingroup`",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xbingroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "xbins": {
-          "editType": "calc",
-          "end": {
-            "description": "Sets the end value for the x axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_end=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "role": "object",
-          "size": {
-            "description": "Sets the size of each x axis bin. Default behavior: If `nbinsx` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsx` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "start": {
-            "description": "Sets the starting value for the x axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_start=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "magic_underscores": "fig.update_traces(xbins=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "ybingroup": {
-          "description": "Set a group of histogram traces which will have compatible y-bin settings. Using `ybingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible y-bin settings. Note that the same `ybingroup` value can be used to set (1D) histogram `bingroup`",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(ybingroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "ybins": {
-          "editType": "calc",
-          "end": {
-            "description": "Sets the end value for the y axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_end=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "role": "object",
-          "size": {
-            "description": "Sets the size of each y axis bin. Default behavior: If `nbinsy` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsy` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "start": {
-            "description": "Sets the starting value for the y axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_start=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "magic_underscores": "fig.update_traces(ybins=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "marker": {
-          "color": {
-            "description": "Sets the aggregation data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "calc",
-          "role": "object",
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "textfont": {
-          "color": {
-            "dflt": "auto",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "description": "Sets the text font.",
-          "editType": "plot",
-          "family": {
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "plot",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "lineposition": {
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "plot",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "role": "object",
-          "shadow": {
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "size": {
-            "dflt": "auto",
-            "editType": "plot",
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "style": {
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "italic"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "textcase": {
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "variant": {
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "weight": {
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "colorbar": {
-          "bgcolor": {
-            "description": "Sets the color of padded area.",
-            "dflt": "rgba(0,0,0,0)",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "bordercolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "borderwidth": {
-            "description": "Sets the width (in px) or the border enclosing this color bar.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "dtick": {
-            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "editType": "colorbars",
-          "exponentformat": {
-            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-            "dflt": "B",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "none",
-              "e",
-              "E",
-              "power",
-              "SI",
-              "B",
-              "SI extended"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "labelalias": {
-            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "len": {
-            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "lenmode": {
-            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-            "dflt": "fraction",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "minexponent": {
-            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-            "dflt": 3,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "nticks": {
-            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "orientation": {
-            "description": "Sets the orientation of the colorbar.",
-            "dflt": "v",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "h",
-              "v"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "outlinecolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "outlinewidth": {
-            "description": "Sets the width (in px) of the axis line.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "role": "object",
-          "separatethousands": {
-            "description": "If \"true\", even 4-digit integers are separated",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "showexponent": {
-            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "showticklabels": {
-            "description": "Determines whether or not the tick labels are drawn.",
-            "dflt": true,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "showtickprefix": {
-            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "showticksuffix": {
-            "description": "Same as `showtickprefix` but for tick suffixes.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-            "dflt": 30,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "thicknessmode": {
-            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-            "dflt": "pixels",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tick0": {
-            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tickangle": {
-            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-            "dflt": "auto",
-            "editType": "colorbars",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tickcolor": {
-            "description": "Sets the tick color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tickfont": {
-            "color": {
-              "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "description": "Sets the color bar's tick label font",
-            "editType": "colorbars",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "colorbars",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "colorbars",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "size": {
-              "editType": "colorbars",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='histogram2d'))"
-          },
-          "tickformat": {
-            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tickformatstops": {
-            "items": {
-              "tickformatstop": {
-                "dtickrange": {
-                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "colorbars",
-                  "items": [
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    },
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "editType": "colorbars",
-                "enabled": {
-                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                  "dflt": true,
-                  "editType": "colorbars",
-                  "valType": "boolean"
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "value": {
-                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                  "dflt": "",
-                  "editType": "colorbars",
-                  "valType": "string"
-                }
-              }
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='histogram2d'))"
-          },
-          "ticklabeloverflow": {
-            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "allow",
-              "hide past div",
-              "hide past domain"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ticklabelposition": {
-            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-            "dflt": "outside",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              "outside top",
-              "inside top",
-              "outside left",
-              "inside left",
-              "outside right",
-              "inside right",
-              "outside bottom",
-              "inside bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ticklabelstep": {
-            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ticklen": {
-            "description": "Sets the tick length (in px).",
-            "dflt": 5,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tickmode": {
-            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "valType": "enumerated",
-            "values": [
-              "auto",
-              "linear",
-              "array"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tickprefix": {
-            "description": "Sets a tick label prefix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ticks": {
-            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              ""
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ticksuffix": {
-            "description": "Sets a tick label suffix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ticktext": {
-            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickvals": {
-            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickwidth": {
-            "description": "Sets the tick width (in px).",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "title": {
-            "editType": "colorbars",
-            "font": {
-              "color": {
-                "editType": "colorbars",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "description": "Sets this color bar's title font.",
-              "editType": "colorbars",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "size": {
-                "editType": "colorbars",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-              },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='histogram2d'))"
-            },
-            "role": "object",
-            "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "right",
-                "top",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "text": {
-              "description": "Sets the title of the color bar.",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='histogram2d'))"
-          },
-          "x": {
-            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "xanchor": {
-            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "xpad": {
-            "description": "Sets the amount of padding (in px) along the x direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "xref": {
-            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "y": {
-            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "yanchor": {
-            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "top",
-              "middle",
-              "bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "ypad": {
-            "description": "Sets the amount of padding (in px) along the y direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "yref": {
-            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "autocolorscale": {
-          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": false,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "showscale": {
-          "description": "Determines whether or not a colorbar is displayed for this trace.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
-          "dflt": false,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "zauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "zmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
-          "dflt": null,
-          "editType": "plot",
-          "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "zmid": {
-          "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "zmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
-          "dflt": null,
-          "editType": "plot",
-          "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "zsmooth": {
-          "description": "Picks a smoothing algorithm use to smooth `z` data.",
-          "dflt": false,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "fast",
-            "best",
-            false
-          ],
-          "magic_underscores": "fig.update_traces(zsmooth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "right",
-              "auto"
-            ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bordercolor": {
-            "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "none",
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "none",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "none",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "none",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "size": {
-              "arrayOk": true,
-              "editType": "none",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='histogram2d'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "ycalendar": {
-          "description": "Sets the calendar system to use with `y` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='histogram2d'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='histogram2d'))"
-      },
-      "categories": [
-        "cartesian",
-        "svg",
-        "2dMap",
-        "histogram",
-        "showLegend"
-      ],
-      "meta": {
-        "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a heatmap.",
-        "hrName": "histogram_2d"
-      },
-      "type": "histogram2d"
-    },
-    "histogram2dcontour": {
-      "animatable": false,
-      "attributes": {
-        "type": "histogram2dcontour",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "size": {
-              "editType": "style",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='histogram2dcontour'))"
-          },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x": {
-          "description": "Sets the sample data to be binned on the x axis.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y": {
-          "description": "Sets the sample data to be binned on the y axis.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "z": {
-          "description": "Sets the aggregation data.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "texttemplate": {
-          "description": "For this trace it only has an effect if `coloring` is set to *heatmap*. Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `x`, `y`, `z` and `text`.",
-          "dflt": "",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "texttemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
-          "editType": "none",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "x",
-            "y",
-            "z",
-            "text",
-            "name"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `z` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xaxis": {
-          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
-          "dflt": "x",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "yaxis": {
-          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
-          "dflt": "y",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "coloraxis": {
-          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-          "dflt": null,
-          "editType": "calc",
-          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "histfunc": {
-          "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.",
-          "dflt": "count",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "count",
-            "sum",
-            "avg",
-            "min",
-            "max"
-          ],
-          "magic_underscores": "fig.update_traces(histfunc=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "histnorm": {
-          "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "",
-            "percent",
-            "probability",
-            "density",
-            "probability density"
-          ],
-          "magic_underscores": "fig.update_traces(histnorm=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "nbinsx": {
-          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `xbins.size` is provided.",
-          "dflt": 0,
-          "editType": "calc",
-          "min": 0,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(nbinsx=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "nbinsy": {
-          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `ybins.size` is provided.",
-          "dflt": 0,
-          "editType": "calc",
-          "min": 0,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(nbinsy=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "autobinx": {
-          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobinx` is not needed. However, we accept `autobinx: true` or `false` and will update `xbins` accordingly before deleting `autobinx` from the trace.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autobinx=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "autobiny": {
-          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobiny` is not needed. However, we accept `autobiny: true` or `false` and will update `ybins` accordingly before deleting `autobiny` from the trace.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autobiny=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "bingroup": {
-          "description": "Set the `xbingroup` and `ybingroup` default prefix For example, setting a `bingroup` of *1* on two histogram2d traces will make them their x-bins and y-bins match separately.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(bingroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "xbingroup": {
-          "description": "Set a group of histogram traces which will have compatible x-bin settings. Using `xbingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible x-bin settings. Note that the same `xbingroup` value can be used to set (1D) histogram `bingroup`",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xbingroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "xbins": {
-          "editType": "calc",
-          "end": {
-            "description": "Sets the end value for the x axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_end=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "role": "object",
-          "size": {
-            "description": "Sets the size of each x axis bin. Default behavior: If `nbinsx` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsx` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "start": {
-            "description": "Sets the starting value for the x axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(xbins_start=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(xbins=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "ybingroup": {
-          "description": "Set a group of histogram traces which will have compatible y-bin settings. Using `ybingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible y-bin settings. Note that the same `ybingroup` value can be used to set (1D) histogram `bingroup`",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(ybingroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "ybins": {
-          "editType": "calc",
-          "end": {
-            "description": "Sets the end value for the y axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_end=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "role": "object",
-          "size": {
-            "description": "Sets the size of each y axis bin. Default behavior: If `nbinsy` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsy` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "start": {
-            "description": "Sets the starting value for the y axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(ybins_start=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(ybins=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "marker": {
-          "color": {
-            "description": "Sets the aggregation data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "calc",
-          "role": "object",
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "line": {
-          "color": {
-            "description": "Sets the color of the contour level. Has no effect if `contours.coloring` is set to *lines*.",
-            "editType": "style+colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "dash": {
-            "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
-            "dflt": "solid",
-            "editType": "style",
-            "valType": "string",
-            "values": [
-              "solid",
-              "dot",
-              "dash",
-              "longdash",
-              "dashdot",
-              "longdashdot"
-            ],
-            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "editType": "plot",
-          "role": "object",
-          "smoothing": {
-            "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing.",
-            "dflt": 1,
-            "editType": "plot",
-            "max": 1.3,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(line_smoothing=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "width": {
-            "description": "Sets the contour line width in (in px)",
-            "dflt": 0.5,
-            "editType": "style+colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "textfont": {
-          "color": {
-            "dflt": "auto",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "description": "For this trace it only has an effect if `coloring` is set to *heatmap*. Sets the text font.",
-          "editType": "plot",
-          "family": {
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "plot",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "lineposition": {
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "plot",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "role": "object",
-          "shadow": {
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "size": {
-            "dflt": "auto",
-            "editType": "plot",
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "style": {
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "italic"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "textcase": {
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "variant": {
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "weight": {
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "colorbar": {
-          "bgcolor": {
-            "description": "Sets the color of padded area.",
-            "dflt": "rgba(0,0,0,0)",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "bordercolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "borderwidth": {
-            "description": "Sets the width (in px) or the border enclosing this color bar.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "dtick": {
-            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "editType": "colorbars",
-          "exponentformat": {
-            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-            "dflt": "B",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "none",
-              "e",
-              "E",
-              "power",
-              "SI",
-              "B",
-              "SI extended"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "labelalias": {
-            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "len": {
-            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "lenmode": {
-            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-            "dflt": "fraction",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "minexponent": {
-            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-            "dflt": 3,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "nticks": {
-            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "orientation": {
-            "description": "Sets the orientation of the colorbar.",
-            "dflt": "v",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "h",
-              "v"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "outlinecolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "outlinewidth": {
-            "description": "Sets the width (in px) of the axis line.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "role": "object",
-          "separatethousands": {
-            "description": "If \"true\", even 4-digit integers are separated",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "showexponent": {
-            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "showticklabels": {
-            "description": "Determines whether or not the tick labels are drawn.",
-            "dflt": true,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "showtickprefix": {
-            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "showticksuffix": {
-            "description": "Same as `showtickprefix` but for tick suffixes.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-            "dflt": 30,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "thicknessmode": {
-            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-            "dflt": "pixels",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tick0": {
-            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tickangle": {
-            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-            "dflt": "auto",
-            "editType": "colorbars",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tickcolor": {
-            "description": "Sets the tick color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tickfont": {
-            "color": {
-              "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "description": "Sets the color bar's tick label font",
-            "editType": "colorbars",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "colorbars",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "colorbars",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "size": {
-              "editType": "colorbars",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='histogram2dcontour'))"
-          },
-          "tickformat": {
-            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tickformatstops": {
-            "items": {
-              "tickformatstop": {
-                "dtickrange": {
-                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "colorbars",
-                  "items": [
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    },
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "editType": "colorbars",
-                "enabled": {
-                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                  "dflt": true,
-                  "editType": "colorbars",
-                  "valType": "boolean"
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "value": {
-                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                  "dflt": "",
-                  "editType": "colorbars",
-                  "valType": "string"
-                }
-              }
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='histogram2dcontour'))"
-          },
-          "ticklabeloverflow": {
-            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "allow",
-              "hide past div",
-              "hide past domain"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ticklabelposition": {
-            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-            "dflt": "outside",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              "outside top",
-              "inside top",
-              "outside left",
-              "inside left",
-              "outside right",
-              "inside right",
-              "outside bottom",
-              "inside bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ticklabelstep": {
-            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ticklen": {
-            "description": "Sets the tick length (in px).",
-            "dflt": 5,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tickmode": {
-            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "valType": "enumerated",
-            "values": [
-              "auto",
-              "linear",
-              "array"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tickprefix": {
-            "description": "Sets a tick label prefix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ticks": {
-            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              ""
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ticksuffix": {
-            "description": "Sets a tick label suffix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ticktext": {
-            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickvals": {
-            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickwidth": {
-            "description": "Sets the tick width (in px).",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "title": {
-            "editType": "colorbars",
-            "font": {
-              "color": {
-                "editType": "colorbars",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "description": "Sets this color bar's title font.",
-              "editType": "colorbars",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "size": {
-                "editType": "colorbars",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-              },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='histogram2dcontour'))"
-            },
-            "role": "object",
-            "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "right",
-                "top",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "text": {
-              "description": "Sets the title of the color bar.",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='histogram2dcontour'))"
-          },
-          "x": {
-            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "xanchor": {
-            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "xpad": {
-            "description": "Sets the amount of padding (in px) along the x direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "xref": {
-            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "y": {
-            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "yanchor": {
-            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "top",
-              "middle",
-              "bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "ypad": {
-            "description": "Sets the amount of padding (in px) along the y direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "yref": {
-            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "autocolorscale": {
-          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "showscale": {
-          "description": "Determines whether or not a colorbar is displayed for this trace.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
-          "dflt": false,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "zauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "zmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "zmid": {
-          "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "zmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "autocontour": {
-          "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocontour_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocontour=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "contours": {
-          "coloring": {
-            "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *heatmap*, a heatmap gradient coloring is applied between each contour level. If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace.",
-            "dflt": "fill",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "fill",
-              "heatmap",
-              "lines",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(contours_coloring=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "editType": "calc",
-          "end": {
-            "description": "Sets the end contour level value. Must be more than `contours.start`",
-            "dflt": null,
-            "editType": "plot",
-            "impliedEdits": {
-              "^autocontour": false,
-              "magic_underscores": "fig.update_traces(contours_end_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(contours_end=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "impliedEdits": {
-            "autocontour": false,
-            "role": "object",
-            "magic_underscores": "fig.update_traces(contours_impliedEdits=dict(...), selector=dict(type='histogram2dcontour'))"
-          },
-          "labelfont": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(contours_labelfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.",
-            "editType": "plot",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "plot",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(contours_labelfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "plot",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(contours_labelfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(contours_labelfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "size": {
-              "editType": "plot",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_labelfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(contours_labelfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(contours_labelfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(contours_labelfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "plot",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(contours_labelfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "magic_underscores": "fig.update_traces(contours_labelfont=dict(...), selector=dict(type='histogram2dcontour'))"
-          },
-          "labelformat": {
-            "description": "Sets the contour label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
-            "dflt": "",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(contours_labelformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "operation": {
-            "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms.",
-            "dflt": "=",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "=",
-              "<",
-              ">=",
-              ">",
-              "<=",
-              "[]",
-              "()",
-              "[)",
-              "(]",
-              "][",
-              ")(",
-              "](",
-              ")["
-            ],
-            "magic_underscores": "fig.update_traces(contours_operation=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "role": "object",
-          "showlabels": {
-            "description": "Determines whether to label the contour lines with their values.",
-            "dflt": false,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(contours_showlabels=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "showlines": {
-            "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*.",
-            "dflt": true,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(contours_showlines=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "size": {
-            "description": "Sets the step between each contour level. Must be positive.",
-            "dflt": null,
-            "editType": "plot",
-            "impliedEdits": {
-              "^autocontour": false,
-              "magic_underscores": "fig.update_traces(contours_size_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(contours_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "start": {
-            "description": "Sets the starting contour level value. Must be less than `contours.end`",
-            "dflt": null,
-            "editType": "plot",
-            "impliedEdits": {
-              "^autocontour": false,
-              "magic_underscores": "fig.update_traces(contours_start_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(contours_start=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "type": {
-            "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters.",
-            "dflt": "levels",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "levels",
-              "constraint"
-            ],
-            "magic_underscores": "fig.update_traces(contours_type=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "value": {
-            "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (`=,<,>=,>,<=`) *value* is expected to be a number. When `operation` is set to one of the interval values (`[],(),[),(],][,)(,](,)[`) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound.",
-            "dflt": 0,
-            "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(contours_value=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(contours=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "right",
-              "auto"
-            ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bordercolor": {
-            "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "none",
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "none",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "none",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "none",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "size": {
-              "arrayOk": true,
-              "editType": "none",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='histogram2dcontour'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "ncontours": {
-          "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing.",
-          "dflt": 15,
-          "editType": "calc",
-          "min": 1,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(ncontours=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "ycalendar": {
-          "description": "Sets the calendar system to use with `y` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='histogram2dcontour'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='histogram2dcontour'))"
-      },
-      "categories": [
-        "cartesian",
-        "svg",
-        "2dMap",
-        "contour",
-        "histogram",
-        "showLegend"
-      ],
-      "meta": {
-        "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a contour plot.",
-        "hrName": "histogram_2d_contour"
-      },
-      "type": "histogram2dcontour"
-    },
-    "ohlc": {
-      "animatable": false,
-      "attributes": {
-        "type": "ohlc",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "size": {
-              "editType": "style",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='ohlc'))"
+              0,
+              "0",
+              "circle",
+              100,
+              "100",
+              "circle-open",
+              200,
+              "200",
+              "circle-dot",
+              300,
+              "300",
+              "circle-open-dot",
+              1,
+              "1",
+              "square",
+              101,
+              "101",
+              "square-open",
+              201,
+              "201",
+              "square-dot",
+              301,
+              "301",
+              "square-open-dot",
+              2,
+              "2",
+              "diamond",
+              102,
+              "102",
+              "diamond-open",
+              202,
+              "202",
+              "diamond-dot",
+              302,
+              "302",
+              "diamond-open-dot",
+              3,
+              "3",
+              "cross",
+              103,
+              "103",
+              "cross-open",
+              203,
+              "203",
+              "cross-dot",
+              303,
+              "303",
+              "cross-open-dot",
+              4,
+              "4",
+              "x",
+              104,
+              "104",
+              "x-open",
+              204,
+              "204",
+              "x-dot",
+              304,
+              "304",
+              "x-open-dot",
+              5,
+              "5",
+              "triangle-up",
+              105,
+              "105",
+              "triangle-up-open",
+              205,
+              "205",
+              "triangle-up-dot",
+              305,
+              "305",
+              "triangle-up-open-dot",
+              6,
+              "6",
+              "triangle-down",
+              106,
+              "106",
+              "triangle-down-open",
+              206,
+              "206",
+              "triangle-down-dot",
+              306,
+              "306",
+              "triangle-down-open-dot",
+              7,
+              "7",
+              "triangle-left",
+              107,
+              "107",
+              "triangle-left-open",
+              207,
+              "207",
+              "triangle-left-dot",
+              307,
+              "307",
+              "triangle-left-open-dot",
+              8,
+              "8",
+              "triangle-right",
+              108,
+              "108",
+              "triangle-right-open",
+              208,
+              "208",
+              "triangle-right-dot",
+              308,
+              "308",
+              "triangle-right-open-dot",
+              9,
+              "9",
+              "triangle-ne",
+              109,
+              "109",
+              "triangle-ne-open",
+              209,
+              "209",
+              "triangle-ne-dot",
+              309,
+              "309",
+              "triangle-ne-open-dot",
+              10,
+              "10",
+              "triangle-se",
+              110,
+              "110",
+              "triangle-se-open",
+              210,
+              "210",
+              "triangle-se-dot",
+              310,
+              "310",
+              "triangle-se-open-dot",
+              11,
+              "11",
+              "triangle-sw",
+              111,
+              "111",
+              "triangle-sw-open",
+              211,
+              "211",
+              "triangle-sw-dot",
+              311,
+              "311",
+              "triangle-sw-open-dot",
+              12,
+              "12",
+              "triangle-nw",
+              112,
+              "112",
+              "triangle-nw-open",
+              212,
+              "212",
+              "triangle-nw-dot",
+              312,
+              "312",
+              "triangle-nw-open-dot",
+              13,
+              "13",
+              "pentagon",
+              113,
+              "113",
+              "pentagon-open",
+              213,
+              "213",
+              "pentagon-dot",
+              313,
+              "313",
+              "pentagon-open-dot",
+              14,
+              "14",
+              "hexagon",
+              114,
+              "114",
+              "hexagon-open",
+              214,
+              "214",
+              "hexagon-dot",
+              314,
+              "314",
+              "hexagon-open-dot",
+              15,
+              "15",
+              "hexagon2",
+              115,
+              "115",
+              "hexagon2-open",
+              215,
+              "215",
+              "hexagon2-dot",
+              315,
+              "315",
+              "hexagon2-open-dot",
+              16,
+              "16",
+              "octagon",
+              116,
+              "116",
+              "octagon-open",
+              216,
+              "216",
+              "octagon-dot",
+              316,
+              "316",
+              "octagon-open-dot",
+              17,
+              "17",
+              "star",
+              117,
+              "117",
+              "star-open",
+              217,
+              "217",
+              "star-dot",
+              317,
+              "317",
+              "star-open-dot",
+              18,
+              "18",
+              "hexagram",
+              118,
+              "118",
+              "hexagram-open",
+              218,
+              "218",
+              "hexagram-dot",
+              318,
+              "318",
+              "hexagram-open-dot",
+              19,
+              "19",
+              "star-triangle-up",
+              119,
+              "119",
+              "star-triangle-up-open",
+              219,
+              "219",
+              "star-triangle-up-dot",
+              319,
+              "319",
+              "star-triangle-up-open-dot",
+              20,
+              "20",
+              "star-triangle-down",
+              120,
+              "120",
+              "star-triangle-down-open",
+              220,
+              "220",
+              "star-triangle-down-dot",
+              320,
+              "320",
+              "star-triangle-down-open-dot",
+              21,
+              "21",
+              "star-square",
+              121,
+              "121",
+              "star-square-open",
+              221,
+              "221",
+              "star-square-dot",
+              321,
+              "321",
+              "star-square-open-dot",
+              22,
+              "22",
+              "star-diamond",
+              122,
+              "122",
+              "star-diamond-open",
+              222,
+              "222",
+              "star-diamond-dot",
+              322,
+              "322",
+              "star-diamond-open-dot",
+              23,
+              "23",
+              "diamond-tall",
+              123,
+              "123",
+              "diamond-tall-open",
+              223,
+              "223",
+              "diamond-tall-dot",
+              323,
+              "323",
+              "diamond-tall-open-dot",
+              24,
+              "24",
+              "diamond-wide",
+              124,
+              "124",
+              "diamond-wide-open",
+              224,
+              "224",
+              "diamond-wide-dot",
+              324,
+              "324",
+              "diamond-wide-open-dot",
+              25,
+              "25",
+              "hourglass",
+              125,
+              "125",
+              "hourglass-open",
+              26,
+              "26",
+              "bowtie",
+              126,
+              "126",
+              "bowtie-open",
+              27,
+              "27",
+              "circle-cross",
+              127,
+              "127",
+              "circle-cross-open",
+              28,
+              "28",
+              "circle-x",
+              128,
+              "128",
+              "circle-x-open",
+              29,
+              "29",
+              "square-cross",
+              129,
+              "129",
+              "square-cross-open",
+              30,
+              "30",
+              "square-x",
+              130,
+              "130",
+              "square-x-open",
+              31,
+              "31",
+              "diamond-cross",
+              131,
+              "131",
+              "diamond-cross-open",
+              32,
+              "32",
+              "diamond-x",
+              132,
+              "132",
+              "diamond-x-open",
+              33,
+              "33",
+              "cross-thin",
+              133,
+              "133",
+              "cross-thin-open",
+              34,
+              "34",
+              "x-thin",
+              134,
+              "134",
+              "x-thin-open",
+              35,
+              "35",
+              "asterisk",
+              135,
+              "135",
+              "asterisk-open",
+              36,
+              "36",
+              "hash",
+              136,
+              "136",
+              "hash-open",
+              236,
+              "236",
+              "hash-dot",
+              336,
+              "336",
+              "hash-open-dot",
+              37,
+              "37",
+              "y-up",
+              137,
+              "137",
+              "y-up-open",
+              38,
+              "38",
+              "y-down",
+              138,
+              "138",
+              "y-down-open",
+              39,
+              "39",
+              "y-left",
+              139,
+              "139",
+              "y-left-open",
+              40,
+              "40",
+              "y-right",
+              140,
+              "140",
+              "y-right-open",
+              41,
+              "41",
+              "line-ew",
+              141,
+              "141",
+              "line-ew-open",
+              42,
+              "42",
+              "line-ns",
+              142,
+              "142",
+              "line-ns-open",
+              43,
+              "43",
+              "line-ne",
+              143,
+              "143",
+              "line-ne-open",
+              44,
+              "44",
+              "line-nw",
+              144,
+              "144",
+              "line-nw-open",
+              45,
+              "45",
+              "arrow-up",
+              145,
+              "145",
+              "arrow-up-open",
+              46,
+              "46",
+              "arrow-down",
+              146,
+              "146",
+              "arrow-down-open",
+              47,
+              "47",
+              "arrow-left",
+              147,
+              "147",
+              "arrow-left-open",
+              48,
+              "48",
+              "arrow-right",
+              148,
+              "148",
+              "arrow-right-open",
+              49,
+              "49",
+              "arrow-bar-up",
+              149,
+              "149",
+              "arrow-bar-up-open",
+              50,
+              "50",
+              "arrow-bar-down",
+              150,
+              "150",
+              "arrow-bar-down-open",
+              51,
+              "51",
+              "arrow-bar-left",
+              151,
+              "151",
+              "arrow-bar-left-open",
+              52,
+              "52",
+              "arrow-bar-right",
+              152,
+              "152",
+              "arrow-bar-right-open",
+              53,
+              "53",
+              "arrow",
+              153,
+              "153",
+              "arrow-open",
+              54,
+              "54",
+              "arrow-wide",
+              154,
+              "154",
+              "arrow-wide-open"
+            ],
+            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='violin'))"
+        },
+        "line": {
+          "color": {
+            "description": "Sets the color of line bounding the violin(s).",
             "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='ohlc'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "zorder": {
-          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
-          "dflt": 0,
           "editType": "plot",
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "x": {
-          "description": "Sets the x coordinates. If absent, linear coordinate will be generated.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "close": {
-          "description": "Sets the close values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(close=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "closesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `close`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "open": {
-          "description": "Sets the open values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(open=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "opensrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `open`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "high": {
-          "description": "Sets the high values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(high=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "highsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `high`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "low": {
-          "description": "Sets the low values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(low=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "lowsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `low`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "text": {
-          "arrayOk": true,
-          "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Same as `text`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
-          "editType": "none",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "x",
-            "y",
-            "z",
-            "text",
-            "name"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `open`, `high`, `low` and `close`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+          "role": "object",
+          "width": {
+            "description": "Sets the width (in px) of line bounding the violin(s).",
+            "dflt": 2,
+            "editType": "style",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          },
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='violin'))"
         },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+        "box": {
           "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xaxis": {
-          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
-          "dflt": "x",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "yaxis": {
-          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
-          "dflt": "y",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "xperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
-          "dflt": 0,
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "xperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
-          "dflt": "middle",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "start",
-            "middle",
-            "end"
-          ],
-          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "xperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "line": {
-          "dash": {
-            "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*). Note that this style setting can also be set per direction via `increasing.line.dash` and `decreasing.line.dash`.",
-            "dflt": "solid",
+          "fillcolor": {
+            "description": "Sets the inner box plot fill color.",
             "editType": "style",
-            "valType": "string",
-            "values": [
-              "solid",
-              "dot",
-              "dash",
-              "longdash",
-              "dashdot",
-              "longdashdot"
-            ],
-            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(box_fillcolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          },
+          "line": {
+            "color": {
+              "description": "Sets the inner box plot bounding line color.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(box_line_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            },
+            "editType": "style",
+            "role": "object",
+            "width": {
+              "description": "Sets the inner box plot bounding line width.",
+              "editType": "style",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(box_line_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
+            },
+            "magic_underscores": "fig.update_traces(box_line=dict(...), selector=dict(type='violin'))"
           },
-          "editType": "style",
           "role": "object",
+          "visible": {
+            "description": "Determines if an miniature box plot is drawn inside the violins. ",
+            "dflt": false,
+            "editType": "plot",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(box_visible=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          },
           "width": {
-            "description": "[object Object] Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`.",
-            "dflt": 2,
-            "editType": "style",
+            "description": "Sets the width of the inner box plots relative to the violins' width. For example, with 1, the inner box plots are as wide as the violins.",
+            "dflt": 0.25,
+            "editType": "plot",
+            "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+            "magic_underscores": "fig.update_traces(box_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='ohlc'))"
+          "magic_underscores": "fig.update_traces(box=dict(...), selector=dict(type='violin'))"
+        },
+        "quartilemethod": {
+          "description": "Sets the method used to compute the sample's Q1 and Q3 quartiles. The *linear* method uses the 25th percentile for Q1 and 75th percentile for Q3 as computed using method #10 (listed on http://jse.amstat.org/v14n3/langford.html). The *exclusive* method uses the median to divide the ordered dataset into two halves if the sample is odd, it does not include the median in either half - Q1 is then the median of the lower half and Q3 the median of the upper half. The *inclusive* method also uses the median to divide the ordered dataset into two halves but if the sample is odd, it includes the median in both halves - Q1 is then the median of the lower half and Q3 the median of the upper half.",
+          "dflt": "linear",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "linear",
+            "exclusive",
+            "inclusive"
+          ],
+          "magic_underscores": "fig.update_traces(quartilemethod=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "selectedpoints": {
           "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
-        "increasing": {
+        "selected": {
           "editType": "style",
-          "line": {
+          "marker": {
             "color": {
-              "description": "Sets the line color.",
-              "dflt": "#3D9970",
+              "description": "Sets the marker color of selected points.",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(increasing_line_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "dash": {
-              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
-              "dflt": "solid",
+            "editType": "style",
+            "opacity": {
+              "description": "Sets the marker opacity of selected points.",
               "editType": "style",
-              "valType": "string",
-              "values": [
-                "solid",
-                "dot",
-                "dash",
-                "longdash",
-                "dashdot",
-                "longdashdot"
-              ],
-              "magic_underscores": "fig.update_traces(increasing_line_dash=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "editType": "style",
             "role": "object",
-            "width": {
-              "description": "Sets the line width (in px).",
-              "dflt": 2,
+            "size": {
+              "description": "Sets the marker size of selected points.",
               "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(increasing_line_width=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "magic_underscores": "fig.update_traces(increasing_line=dict(...), selector=dict(type='ohlc'))"
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='violin'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(increasing=dict(...), selector=dict(type='ohlc'))"
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='violin'))"
         },
-        "decreasing": {
+        "unselected": {
           "editType": "style",
-          "line": {
+          "marker": {
             "color": {
-              "description": "Sets the line color.",
-              "dflt": "#FF4136",
+              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(decreasing_line_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "dash": {
-              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
-              "dflt": "solid",
+            "editType": "style",
+            "opacity": {
+              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
               "editType": "style",
-              "valType": "string",
-              "values": [
-                "solid",
-                "dot",
-                "dash",
-                "longdash",
-                "dashdot",
-                "longdashdot"
-              ],
-              "magic_underscores": "fig.update_traces(decreasing_line_dash=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "editType": "style",
             "role": "object",
-            "width": {
-              "description": "Sets the line width (in px).",
-              "dflt": 2,
+            "size": {
+              "description": "Sets the marker size of unselected points, applied only when a selection exists.",
               "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(decreasing_line_width=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "magic_underscores": "fig.update_traces(decreasing_line=dict(...), selector=dict(type='ohlc'))"
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='violin'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(decreasing=dict(...), selector=dict(type='ohlc'))"
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='violin'))"
+        },
+        "bandwidth": {
+          "description": "Sets the bandwidth used to compute the kernel density estimate. By default, the bandwidth is determined by Silverman's rule of thumb.",
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(bandwidth=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "fillcolor": {
+          "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
+          "editType": "style",
+          "valType": "color",
+          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "hoverlabel": {
           "align": {
@@ -43806,36 +35353,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
           "editType": "none",
           "font": {
@@ -43843,12 +35375,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -43859,12 +35386,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -43880,12 +35402,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "role": "object",
             "shadow": {
@@ -43894,24 +35411,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "style": {
               "arrayOk": true,
@@ -43923,12 +35430,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -43942,12 +35444,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "variant": {
               "arrayOk": true,
@@ -43963,12 +35460,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
             "weight": {
               "arrayOk": true,
@@ -43982,14 +35474,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='violin'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='ohlc'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='violin'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -43998,119 +35485,210 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
+          "role": "object",
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
             "editType": "none",
-            "valType": "string"
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='violin'))"
+          },
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='violin'))"
+        },
+        "hoveron": {
+          "description": "Do the hover effects highlight individual violins or sample points or the kernel density estimate or any combination of them?",
+          "dflt": "violins+points+kde",
+          "editType": "style",
+          "extras": [
+            "all"
+          ],
+          "flags": [
+            "violins",
+            "points",
+            "kde"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoveron=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "pointpos": {
+          "description": "Sets the position of the sample points in relation to the violins. If *0*, the sample points are places over the center of the violins. Positive (negative) values correspond to positions to the right (left) for vertical violins and above (below) for horizontal violins.",
+          "editType": "calc",
+          "max": 2,
+          "min": -2,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(pointpos=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "jitter": {
+          "description": "Sets the amount of jitter in the sample points drawn. If *0*, the sample points align along the distribution axis. If *1*, the sample points are drawn in a random jitter of width equal to the width of the violins.",
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(jitter=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "meanline": {
+          "color": {
+            "description": "Sets the mean line color.",
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(meanline_color=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
+          "editType": "plot",
           "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
+          "visible": {
+            "description": "Determines if a line corresponding to the sample's mean is shown inside the violins. If `box.visible` is turned on, the mean line is drawn inside the inner box. Otherwise, the mean line is drawn from one side of the violin to other.",
+            "dflt": false,
+            "editType": "plot",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+            "magic_underscores": "fig.update_traces(meanline_visible=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "split": {
-            "description": "Show hover information (open, close, high, low) in separate labels, rather than a single unified label. Default: *false*. When set to *true*, `hovertemplate` is ignored.",
-            "dflt": false,
+          "width": {
+            "description": "Sets the mean line width.",
             "editType": "style",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_split=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(meanline_width=&lt;VALUE&gt;, selector=dict(type='violin'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='ohlc'))"
+          "magic_underscores": "fig.update_traces(meanline=dict(...), selector=dict(type='violin'))"
         },
-        "tickwidth": {
-          "description": "Sets the width of the open/close tick marks relative to the *x* minimal interval.",
-          "dflt": 0.3,
+        "points": {
+          "description": "If *outliers*, only the sample points lying outside the whiskers are shown If *suspectedoutliers*, the outlier points are shown and points either less than 4*Q1-3*Q3 or greater than 4*Q3-3*Q1 are highlighted (see `outliercolor`) If *all*, all sample points are shown If *false*, only the violins are shown with no sample points. Defaults to *suspectedoutliers* when `marker.outliercolor` or `marker.line.outliercolor` is set, otherwise defaults to *outliers*.",
           "editType": "calc",
-          "max": 0.5,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(tickwidth=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+          "valType": "enumerated",
+          "values": [
+            "all",
+            "outliers",
+            "suspectedoutliers",
+            false
+          ],
+          "magic_underscores": "fig.update_traces(points=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
+        "scalegroup": {
+          "description": "If there are multiple violins that should be sized according to some metric (see `scalemode`), link them by providing a non-empty group id here shared by every trace in the same group. If a violin's `width` is undefined, `scalegroup` will default to the trace's name. In this case, violins with the same names will be linked together",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(scalegroup=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "scalemode": {
+          "description": "Sets the metric by which the width of each violin is determined. *width* means each violin has the same (max) width *count* means the violins are scaled by the number of sample points making up each violin.",
+          "dflt": "width",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
+            "width",
+            "count"
           ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+          "magic_underscores": "fig.update_traces(scalemode=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "side": {
+          "description": "Determines on which side of the position value the density function making up one half of a violin is plotted. Useful when comparing two violin traces under *overlay* mode, where one trace has `side` set to *positive* and the other to *negative*.",
+          "dflt": "both",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "both",
+            "positive",
+            "negative"
+          ],
+          "magic_underscores": "fig.update_traces(side=&lt;VALUE&gt;, selector=dict(type='violin'))"
+        },
+        "span": {
+          "description": "Sets the span in data space for which the density function will be computed. Has an effect only when `spanmode` is set to *manual*.",
+          "editType": "calc",
+          "items": [
+            {
+              "editType": "calc",
+              "valType": "any"
+            },
+            {
+              "editType": "calc",
+              "valType": "any"
+            }
+          ],
+          "valType": "info_array",
+          "magic_underscores": "fig.update_traces(span=list(...), selector=dict(type='violin'))"
+        },
+        "spanmode": {
+          "description": "Sets the method by which the span in data space where the density function will be computed. *soft* means the span goes from the sample's minimum value minus two bandwidths to the sample's maximum value plus two bandwidths. *hard* means the span goes from the sample's minimum to its maximum value. For custom span settings, use mode *manual* and fill in the `span` attribute.",
+          "dflt": "soft",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "soft",
+            "hard",
+            "manual"
+          ],
+          "magic_underscores": "fig.update_traces(spanmode=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='ohlc'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='violin'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='ohlc'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='violin'))"
       },
       "categories": [
         "cartesian",
         "svg",
-        "showLegend"
+        "symbols",
+        "oriented",
+        "box-violin",
+        "showLegend",
+        "violinLayout",
+        "zoomScale"
       ],
+      "layoutAttributes": {
+        "violingap": {
+          "description": "Sets the gap (in plot fraction) between violins of adjacent location coordinates. Has no effect on traces that have *width* set.",
+          "dflt": 0.3,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "violingroupgap": {
+          "description": "Sets the gap (in plot fraction) between violins of the same location coordinate. Has no effect on traces that have *width* set.",
+          "dflt": 0.3,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "violinmode": {
+          "description": "Determines how violins at the same location coordinate are displayed on the graph. If *group*, the violins are plotted next to one another centered around the shared location. If *overlay*, the violins are plotted over one another, you might need to set *opacity* to see them multiple violins. Has no effect on traces that have *width* set.",
+          "dflt": "overlay",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "group",
+            "overlay"
+          ]
+        }
+      },
       "meta": {
-        "description": "The ohlc (short for Open-High-Low-Close) is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The tip of the lines represent the `low` and `high` values and the horizontal segments represent the `open` and `close` values. Sample points where the close value is higher (lower) then the open value are called increasing (decreasing). By default, increasing items are drawn in green whereas decreasing are drawn in red."
+        "description": "In vertical (horizontal) violin plots, statistics are computed using `y` (`x`) values. By supplying an `x` (`y`) array, one violin per distinct x (y) value is drawn If no `x` (`y`) {array} is provided, a single violin is drawn. That violin position is then positioned with `name` or with `x0` (`y0`) if provided."
       },
-      "type": "ohlc"
+      "type": "violin"
     },
-    "candlestick": {
+    "histogram": {
       "animatable": false,
       "attributes": {
-        "type": "candlestick",
+        "type": "histogram",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -44122,35 +35700,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": true,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -44158,7 +35736,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -44168,7 +35746,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -44183,7 +35761,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "role": "object",
             "shadow": {
@@ -44191,13 +35769,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -44208,7 +35786,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -44221,7 +35799,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -44236,7 +35814,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -44249,9 +35827,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='candlestick'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='histogram'))"
           },
           "role": "object",
           "text": {
@@ -44259,16 +35837,16 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='histogram'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "opacity": {
           "description": "Sets the opacity of the trace.",
@@ -44277,110 +35855,80 @@
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
           "editType": "plot",
           "valType": "integer",
-          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "x": {
-          "description": "Sets the x coordinates. If absent, linear coordinate will be generated.",
+          "description": "Sets the sample data to be binned on the x axis.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "close": {
-          "description": "Sets the close values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(close=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "closesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `close`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "open": {
-          "description": "Sets the open values.",
-          "editType": "calc",
+        "y": {
+          "description": "Sets the sample data to be binned on the y axis.",
+          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(open=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "opensrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `open`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "high": {
-          "description": "Sets the high values.",
+        "text": {
+          "arrayOk": true,
+          "description": "Sets hover text elements associated with each bar. If a single string, the same string appears over all bars. If an array of string, the items are mapped in order to the this trace's coordinates.",
+          "dflt": "",
           "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(high=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "highsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `high`.",
-          "editType": "none",
-          "valType": "string"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "low": {
-          "description": "Sets the low values.",
+        "textposition": {
+          "arrayOk": false,
+          "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed), unless there is another bar stacked on this one, then the text gets pushed inside. *auto* tries to position `text` inside the bar, but if the bar is too small and no bar is stacked on this one the text is moved outside. If *none*, no text appears.",
+          "dflt": "auto",
           "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(low=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "lowsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `low`.",
-          "editType": "none",
-          "valType": "string"
+          "valType": "enumerated",
+          "values": [
+            "inside",
+            "outside",
+            "auto",
+            "none"
+          ],
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "text": {
-          "arrayOk": true,
-          "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points.",
+        "texttemplate": {
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label` and `value`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+        "texttemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "hovertext": {
           "arrayOk": true,
           "description": "Same as `text`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -44396,1097 +35944,1190 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `open`, `high`, `low` and `close`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `binNumber` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "yaxis": {
           "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
           "dflt": "y",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "xperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
-          "dflt": 0,
+        "orientation": {
+          "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal).",
+          "editType": "calc+clearAxisTypes",
+          "valType": "enumerated",
+          "values": [
+            "v",
+            "h"
+          ],
+          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+        },
+        "histfunc": {
+          "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.",
+          "dflt": "count",
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "valType": "enumerated",
+          "values": [
+            "count",
+            "sum",
+            "avg",
+            "min",
+            "max"
+          ],
+          "magic_underscores": "fig.update_traces(histfunc=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "xperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
-          "dflt": "middle",
+        "histnorm": {
+          "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).",
+          "dflt": "",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "start",
-            "middle",
-            "end"
+            "",
+            "percent",
+            "probability",
+            "density",
+            "probability density"
           ],
-          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(histnorm=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "xperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+        "alignmentgroup": {
+          "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
+          "dflt": "",
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "line": {
-          "editType": "style",
-          "role": "object",
-          "width": {
-            "description": "Sets the width (in px) of line bounding the box(es). Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`.",
-            "dflt": 2,
-            "editType": "style",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-          },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='candlestick'))"
+        "offsetgroup": {
+          "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "whiskerwidth": {
-          "description": "Sets the width of the whiskers relative to the box width. For example, with 1, the whiskers are as wide as the box(es).",
+        "nbinsx": {
+          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `xbins.size` is provided.",
           "dflt": 0,
           "editType": "calc",
-          "max": 1,
           "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(whiskerwidth=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(nbinsx=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+        "nbinsy": {
+          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `ybins.size` is provided.",
+          "dflt": 0,
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "min": 0,
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(nbinsy=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "increasing": {
-          "editType": "style",
-          "fillcolor": {
-            "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(increasing_fillcolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        "autobinx": {
+          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobinx` is not needed. However, we accept `autobinx: true` or `false` and will update `xbins` accordingly before deleting `autobinx` from the trace.",
+          "dflt": null,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autobinx=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+        },
+        "autobiny": {
+          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobiny` is not needed. However, we accept `autobiny: true` or `false` and will update `ybins` accordingly before deleting `autobiny` from the trace.",
+          "dflt": null,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autobiny=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+        },
+        "bingroup": {
+          "description": "Set a group of histogram traces which will have compatible bin settings. Note that traces on the same subplot and with the same *orientation* under `barmode` *stack*, *relative* and *group* are forced into the same bingroup, Using `bingroup`, traces under `barmode` *overlay* and on different axes (of the same axis type) can have compatible bin settings. Note that histogram and histogram2d* trace can share the same `bingroup`",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(bingroup=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+        },
+        "xbins": {
+          "editType": "calc",
+          "end": {
+            "description": "Sets the end value for the x axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_end=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "line": {
-            "color": {
-              "description": "Sets the color of line bounding the box(es).",
-              "dflt": "#3D9970",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(increasing_line_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-            },
-            "editType": "style",
-            "role": "object",
-            "width": {
-              "description": "Sets the width (in px) of line bounding the box(es).",
-              "dflt": 2,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(increasing_line_width=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-            },
-            "magic_underscores": "fig.update_traces(increasing_line=dict(...), selector=dict(type='candlestick'))"
+          "role": "object",
+          "size": {
+            "description": "Sets the size of each x axis bin. Default behavior: If `nbinsx` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsx` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). If multiple non-overlaying histograms share a subplot, the first explicit `size` is used and all others discarded. If no `size` is provided, the sample data from all traces is combined to determine `size` as described above.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "start": {
+            "description": "Sets the starting value for the x axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. If multiple non-overlaying histograms share a subplot, the first explicit `start` is used exactly and all others are shifted down (if necessary) to differ from that one by an integer number of bins.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_start=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "magic_underscores": "fig.update_traces(xbins=dict(...), selector=dict(type='histogram'))"
+        },
+        "ybins": {
+          "editType": "calc",
+          "end": {
+            "description": "Sets the end value for the y axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_end=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(increasing=dict(...), selector=dict(type='candlestick'))"
-        },
-        "decreasing": {
-          "editType": "style",
-          "fillcolor": {
-            "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(decreasing_fillcolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "size": {
+            "description": "Sets the size of each y axis bin. Default behavior: If `nbinsy` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsy` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). If multiple non-overlaying histograms share a subplot, the first explicit `size` is used and all others discarded. If no `size` is provided, the sample data from all traces is combined to determine `size` as described above.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "line": {
-            "color": {
-              "description": "Sets the color of line bounding the box(es).",
-              "dflt": "#FF4136",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(decreasing_line_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-            },
-            "editType": "style",
-            "role": "object",
-            "width": {
-              "description": "Sets the width (in px) of line bounding the box(es).",
-              "dflt": 2,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(decreasing_line_width=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-            },
-            "magic_underscores": "fig.update_traces(decreasing_line=dict(...), selector=dict(type='candlestick'))"
+          "start": {
+            "description": "Sets the starting value for the y axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. If multiple non-overlaying histograms share a subplot, the first explicit `start` is used exactly and all others are shifted down (if necessary) to differ from that one by an integer number of bins.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_start=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(decreasing=dict(...), selector=dict(type='candlestick'))"
+          "magic_underscores": "fig.update_traces(ybins=dict(...), selector=dict(type='histogram'))"
         },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "right",
-              "auto"
-            ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        "marker": {
+          "autocolorscale": {
+            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+            "dflt": true,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+          "cauto": {
+            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
+            "dflt": true,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          "cmax": {
+            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
+            "dflt": null,
+            "editType": "plot",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+          "cmid": {
+            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "bordercolor": {
+          "cmin": {
+            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
+            "dflt": null,
+            "editType": "plot",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "color": {
             "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
+            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
+            "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+          "coloraxis": {
+            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+            "dflt": null,
+            "editType": "calc",
+            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+            "valType": "subplotid",
+            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "editType": "none",
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "none",
+          "colorbar": {
+            "bgcolor": {
+              "description": "Sets the color of padded area.",
+              "dflt": "rgba(0,0,0,0)",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "bordercolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "colorbars",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            "borderwidth": {
+              "description": "Sets the width (in px) or the border enclosing this color bar.",
+              "dflt": 0,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+            "dtick": {
+              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+              "editType": "colorbars",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "none",
-              "extras": [
-                "none"
+            "editType": "colorbars",
+            "exponentformat": {
+              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+              "dflt": "B",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "none",
+                "e",
+                "E",
+                "power",
+                "SI",
+                "B",
+                "SI extended"
               ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "labelalias": {
+              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+              "dflt": false,
+              "editType": "colorbars",
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "len": {
+              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+              "dflt": 1,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "lenmode": {
+              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+              "dflt": "fraction",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+            "minexponent": {
+              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+              "dflt": 3,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "nticks": {
+              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+              "dflt": 0,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "orientation": {
+              "description": "Sets the orientation of the colorbar.",
+              "dflt": "v",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "h",
+                "v"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "outlinecolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "colorbars",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "outlinewidth": {
+              "description": "Sets the width (in px) of the axis line.",
+              "dflt": 1,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "none",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            "separatethousands": {
+              "description": "If \"true\", even 4-digit integers are separated",
+              "dflt": false,
+              "editType": "colorbars",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+            "showexponent": {
+              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+              "dflt": "all",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "size": {
-              "arrayOk": true,
-              "editType": "none",
-              "min": 1,
+            "showticklabels": {
+              "description": "Determines whether or not the tick labels are drawn.",
+              "dflt": true,
+              "editType": "colorbars",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "showtickprefix": {
+              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+              "dflt": "all",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "showticksuffix": {
+              "description": "Same as `showtickprefix` but for tick suffixes.",
+              "dflt": "all",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "thickness": {
+              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+              "dflt": 30,
+              "editType": "colorbars",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+            "thicknessmode": {
+              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+              "dflt": "pixels",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "tick0": {
+              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+              "editType": "colorbars",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "tickangle": {
+              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+              "dflt": "auto",
+              "editType": "colorbars",
+              "valType": "angle",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "tickcolor": {
+              "description": "Sets the tick color.",
+              "dflt": "#444",
+              "editType": "colorbars",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "tickfont": {
+              "color": {
+                "editType": "colorbars",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "description": "Sets the color bar's tick label font",
+              "editType": "colorbars",
+              "family": {
+                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                "editType": "colorbars",
+                "noBlank": true,
+                "strict": true,
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "lineposition": {
+                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "extras": [
+                  "none"
+                ],
+                "flags": [
+                  "under",
+                  "over",
+                  "through"
+                ],
+                "valType": "flaglist",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "role": "object",
+              "shadow": {
+                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "size": {
+                "editType": "colorbars",
+                "min": 1,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "style": {
+                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "italic"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "textcase": {
+                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='histogram'))"
+            },
+            "tickformat": {
+              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+              "dflt": "",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "tickformatstops": {
+              "items": {
+                "tickformatstop": {
+                  "dtickrange": {
+                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                    "editType": "colorbars",
+                    "items": [
+                      {
+                        "editType": "colorbars",
+                        "valType": "any"
+                      },
+                      {
+                        "editType": "colorbars",
+                        "valType": "any"
+                      }
+                    ],
+                    "valType": "info_array"
+                  },
+                  "editType": "colorbars",
+                  "enabled": {
+                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                    "dflt": true,
+                    "editType": "colorbars",
+                    "valType": "boolean"
+                  },
+                  "name": {
+                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                    "editType": "colorbars",
+                    "valType": "string"
+                  },
+                  "role": "object",
+                  "templateitemname": {
+                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                    "editType": "colorbars",
+                    "valType": "string"
+                  },
+                  "value": {
+                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                    "dflt": "",
+                    "editType": "colorbars",
+                    "valType": "string"
+                  }
+                }
+              },
+              "role": "object",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='histogram'))"
             },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "none",
+            "ticklabeloverflow": {
+              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "allow",
+                "hide past div",
+                "hide past domain"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "none",
+            "ticklabelposition": {
+              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+              "dflt": "outside",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "outside",
+                "inside",
+                "outside top",
+                "inside top",
+                "outside left",
+                "inside left",
+                "outside right",
+                "inside right",
+                "outside bottom",
+                "inside bottom"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+            "ticklabelstep": {
+              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+              "dflt": 1,
+              "editType": "colorbars",
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "none",
+            "ticklen": {
+              "description": "Sets the tick length (in px).",
+              "dflt": 5,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "tickmode": {
+              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+              "editType": "colorbars",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "auto",
+                "linear",
+                "array"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+            "tickprefix": {
+              "description": "Sets a tick label prefix.",
+              "dflt": "",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "extras": [
-                "normal",
-                "bold"
+            "ticks": {
+              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+              "dflt": "",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "outside",
+                "inside",
+                ""
               ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+            "ticksuffix": {
+              "description": "Sets a tick label suffix.",
+              "dflt": "",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='candlestick'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-          },
-          "split": {
-            "description": "Show hover information (open, close, high, low) in separate labels, rather than a single unified label. Default: *false*. When set to *true*, `hovertemplate` is ignored.",
-            "dflt": false,
-            "editType": "style",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_split=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='candlestick'))"
-        },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='candlestick'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='candlestick'))"
-      },
-      "categories": [
-        "cartesian",
-        "svg",
-        "showLegend",
-        "candlestick",
-        "boxLayout"
-      ],
-      "layoutAttributes": {
-        "boxgap": {
-          "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates. Has no effect on traces that have *width* set.",
-          "dflt": 0.3,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
-        },
-        "boxgroupgap": {
-          "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate. Has no effect on traces that have *width* set.",
-          "dflt": 0.3,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
-        },
-        "boxmode": {
-          "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes. Has no effect on traces that have *width* set.",
-          "dflt": "overlay",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "group",
-            "overlay"
-          ]
-        }
-      },
-      "meta": {
-        "description": "The candlestick is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The boxes represent the spread between the `open` and `close` values and the lines represent the spread between the `low` and `high` values Sample points where the close value is higher (lower) then the open value are called increasing (decreasing). By default, increasing candles are drawn in green whereas decreasing are drawn in red."
-      },
-      "type": "candlestick"
-    },
-    "waterfall": {
-      "animatable": false,
-      "attributes": {
-        "type": "waterfall",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "ticktext": {
+              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+              "editType": "colorbars",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "tickvals": {
+              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+              "editType": "colorbars",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "tickwidth": {
+              "description": "Sets the tick width (in px).",
+              "dflt": 1,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "title": {
+              "editType": "colorbars",
+              "font": {
+                "color": {
+                  "editType": "colorbars",
+                  "valType": "color",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "description": "Sets this color bar's title font.",
+                "editType": "colorbars",
+                "family": {
+                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                  "editType": "colorbars",
+                  "noBlank": true,
+                  "strict": true,
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "lineposition": {
+                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                  "dflt": "none",
+                  "editType": "colorbars",
+                  "extras": [
+                    "none"
+                  ],
+                  "flags": [
+                    "under",
+                    "over",
+                    "through"
+                  ],
+                  "valType": "flaglist",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "role": "object",
+                "shadow": {
+                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                  "dflt": "none",
+                  "editType": "colorbars",
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "size": {
+                  "editType": "colorbars",
+                  "min": 1,
+                  "valType": "number",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "style": {
+                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "italic"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "textcase": {
+                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "word caps",
+                    "upper",
+                    "lower"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "variant": {
+                  "description": "Sets the variant of the font.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "small-caps",
+                    "all-small-caps",
+                    "all-petite-caps",
+                    "petite-caps",
+                    "unicase"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "weight": {
+                  "description": "Sets the weight (or boldness) of the font.",
+                  "dflt": "normal",
+                  "editType": "colorbars",
+                  "extras": [
+                    "normal",
+                    "bold"
+                  ],
+                  "max": 1000,
+                  "min": 1,
+                  "valType": "integer",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+                },
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='histogram'))"
+              },
+              "role": "object",
+              "side": {
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "right",
+                  "top",
+                  "bottom"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "text": {
+                "description": "Sets the title of the color bar.",
+                "editType": "colorbars",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='histogram'))"
             },
-            "size": {
-              "editType": "style",
-              "min": 1,
+            "x": {
+              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+              "editType": "colorbars",
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
+            "xanchor": {
+              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "left",
+                "center",
+                "right"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "xpad": {
+              "description": "Sets the amount of padding (in px) along the x direction.",
+              "dflt": 10,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "xref": {
+              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+              "dflt": "paper",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "container",
+                "paper"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
+            "y": {
+              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+              "editType": "colorbars",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "yanchor": {
+              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "top",
+                "middle",
+                "bottom"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
+            "ypad": {
+              "description": "Sets the amount of padding (in px) along the y direction.",
+              "dflt": 10,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "yref": {
+              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+              "dflt": "paper",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "container",
+                "paper"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='histogram'))"
+          },
+          "colorscale": {
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "autocolorscale": false,
+              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='waterfall'))"
+            "valType": "colorscale",
+            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          "cornerradius": {
+            "description": "Sets the rounding of corners. May be an integer number of pixels, or a percentage of bar width (as a string ending in %). Defaults to `layout.barcornerradius`. In stack or relative barmode, the first trace to set cornerradius is used for the whole stack.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(marker_cornerradius=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='waterfall'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "zorder": {
-          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
-          "dflt": 0,
-          "editType": "plot",
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "x": {
-          "description": "Sets the x coordinates.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x0": {
-          "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
-          "dflt": 0,
-          "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "dx": {
-          "description": "Sets the x coordinate step. See `x0` for more info.",
-          "dflt": 1,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(dx=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "y": {
-          "description": "Sets the y coordinates.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y0": {
-          "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
-          "dflt": 0,
-          "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "dy": {
-          "description": "Sets the y coordinate step. See `y0` for more info.",
-          "dflt": 1,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(dy=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "base": {
-          "arrayOk": false,
-          "description": "Sets where the bar base is drawn (in position axis units).",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(base=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "width": {
-          "arrayOk": true,
-          "description": "Sets the bar width (in position axis units).",
-          "dflt": null,
-          "editType": "calc",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "widthsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "measure": {
-          "description": "An array containing types of values. By default the values are considered as 'relative'. However; it is possible to use 'total' to compute the sums. Also 'absolute' could be applied to reset the computed total or to declare an initial value where needed.",
-          "dflt": [],
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(measure=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "measuresrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `measure`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "offset": {
-          "arrayOk": true,
-          "description": "Shifts the position where the bar is drawn (in position axis units). In *group* barmode, traces that set *offset* will be excluded and drawn in *overlay* mode instead.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(offset=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "offsetsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `offset`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "text": {
-          "arrayOk": true,
-          "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "textposition": {
-          "arrayOk": true,
-          "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed), unless there is another bar stacked on this one, then the text gets pushed inside. *auto* tries to position `text` inside the bar, but if the bar is too small and no bar is stacked on this one the text is moved outside. If *none*, no text appears.",
-          "dflt": "auto",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "inside",
-            "outside",
-            "auto",
-            "none"
-          ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "texttemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `initial`, `delta`, `final` and `label`.",
-          "dflt": "",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "texttemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
-          "editType": "none",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "name",
-            "x",
-            "y",
-            "text",
-            "initial",
-            "delta",
-            "final"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `initial`, `delta` and `final`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xaxis": {
-          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
-          "dflt": "x",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "yaxis": {
-          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
-          "dflt": "y",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "orientation": {
-          "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal).",
-          "editType": "calc+clearAxisTypes",
-          "valType": "enumerated",
-          "values": [
-            "v",
-            "h"
-          ],
-          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "alignmentgroup": {
-          "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "offsetgroup": {
-          "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "xperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
-          "dflt": 0,
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "xperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
-          "dflt": "middle",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "start",
-            "middle",
-            "end"
-          ],
-          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "xperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "yperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the y axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
-          "dflt": 0,
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(yperiod=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "yperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the y axis.",
-          "dflt": "middle",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "start",
-            "middle",
-            "end"
-          ],
-          "magic_underscores": "fig.update_traces(yperiodalignment=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "yperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the y0 axis. When `y0period` is round number of weeks, the `y0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(yperiod0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          "line": {
+            "autocolorscale": {
+              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "cauto": {
+              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "cmax": {
+              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
+              "dflt": null,
+              "editType": "plot",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "cmid": {
+              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "cmin": {
+              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
+              "dflt": null,
+              "editType": "plot",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "color": {
+              "arrayOk": true,
+              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "coloraxis": {
+              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+              "dflt": null,
+              "editType": "calc",
+              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+              "valType": "subplotid",
+              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "colorscale": {
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "autocolorscale": false,
+                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+              },
+              "valType": "colorscale",
+              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "editType": "calc",
+            "reversescale": {
+              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
+              "dflt": false,
+              "editType": "plot",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "role": "object",
+            "width": {
+              "arrayOk": true,
+              "description": "Sets the width (in px) of the lines bounding the marker points.",
+              "dflt": 0,
+              "editType": "style",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='histogram'))"
+          },
+          "opacity": {
+            "arrayOk": true,
+            "description": "Sets the opacity of the bars.",
+            "dflt": 1,
+            "editType": "style",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "pattern": {
+            "bgcolor": {
+              "arrayOk": true,
+              "description": "When there is no colorscale sets the color of background pattern fill. Defaults to a `marker.color` background when `fillmode` is *overlay*. Otherwise, defaults to a transparent background.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "description": "Sets the pattern within the marker.",
+            "editType": "style",
+            "fgcolor": {
+              "arrayOk": true,
+              "description": "When there is no colorscale sets the color of foreground pattern fill. Defaults to a `marker.color` background when `fillmode` is *replace*. Otherwise, defaults to dark grey or white to increase contrast with the `bgcolor`.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "fgopacity": {
+              "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
+              "editType": "style",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_pattern_fgopacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "fillmode": {
+              "description": "Determines whether `marker.color` should be used as a default to `bgcolor` or a `fgcolor`.",
+              "dflt": "replace",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "replace",
+                "overlay"
+              ],
+              "magic_underscores": "fig.update_traces(marker_pattern_fillmode=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "path": {
+              "arrayOk": true,
+              "description": "Sets a custom path for pattern fill. Use with no `shape` or `solidity`, provide an SVG path string for the regions of the square from (0,0) to (`size`,`size`) to color.",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "role": "object",
+            "shape": {
+              "arrayOk": true,
+              "description": "Sets the shape of the pattern fill. By default, no pattern is used for filling the area.",
+              "dflt": "",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "",
+                "/",
+                "\\",
+                "x",
+                "-",
+                "|",
+                "+",
+                "."
+              ],
+              "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "size": {
+              "arrayOk": true,
+              "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
+              "dflt": 8,
+              "editType": "style",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "solidity": {
+              "arrayOk": true,
+              "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
+              "dflt": 0.3,
+              "editType": "style",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='histogram'))"
+          },
+          "reversescale": {
+            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
+            "dflt": false,
+            "editType": "plot",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "role": "object",
+          "showscale": {
+            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='histogram'))"
         },
         "textangle": {
           "description": "Sets the angle of the tick labels with respect to the bar. For example, a `tickangle` of -90 draws the tick labels vertically. With *auto* the texts may automatically be rotated to fit with the maximum size in bars.",
           "dflt": "auto",
           "editType": "plot",
           "valType": "angle",
-          "magic_underscores": "fig.update_traces(textangle=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          "magic_underscores": "fig.update_traces(textangle=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "textfont": {
           "color": {
-            "arrayOk": true,
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "description": "Sets the font used for `text`.",
-          "editType": "calc",
+          "description": "Sets the text font.",
+          "editType": "plot",
           "family": {
-            "arrayOk": true,
             "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "calc",
+            "editType": "plot",
             "noBlank": true,
             "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "lineposition": {
-            "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "none"
             ],
@@ -45496,61 +37137,37 @@
               "through"
             ],
             "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "role": "object",
           "shadow": {
-            "arrayOk": true,
             "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "size": {
-            "arrayOk": true,
-            "editType": "calc",
+            "editType": "plot",
             "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "style": {
-            "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
               "italic"
             ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "textcase": {
-            "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -45558,18 +37175,12 @@
               "upper",
               "lower"
             ],
-            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "variant": {
-            "arrayOk": true,
             "description": "Sets the variant of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -45579,18 +37190,12 @@
               "petite-caps",
               "unicase"
             ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "weight": {
-            "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "normal",
               "bold"
@@ -45598,191 +37203,329 @@
             "max": 1000,
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='waterfall'))"
-        },
-        "textinfo": {
-          "arrayOk": false,
-          "description": "Determines which trace information appear on the graph. In the case of having multiple waterfalls, totals are computed separately (per trace).",
-          "editType": "plot",
-          "extras": [
-            "none"
-          ],
-          "flags": [
-            "label",
-            "text",
-            "initial",
-            "delta",
-            "final"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(textinfo=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "cliponaxis": {
-          "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.",
-          "dflt": true,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cliponaxis=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='histogram'))"
         },
-        "connector": {
-          "editType": "plot",
-          "line": {
-            "color": {
-              "description": "Sets the line color.",
-              "dflt": "#444",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(connector_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "dash": {
-              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
-              "dflt": "solid",
-              "editType": "style",
-              "valType": "string",
-              "values": [
-                "solid",
-                "dot",
-                "dash",
-                "longdash",
-                "dashdot",
-                "longdashdot"
-              ],
-              "magic_underscores": "fig.update_traces(connector_line_dash=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "editType": "plot",
-            "role": "object",
-            "width": {
-              "description": "Sets the line width (in px).",
-              "dflt": 2,
-              "editType": "plot",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(connector_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "magic_underscores": "fig.update_traces(connector_line=dict(...), selector=dict(type='waterfall'))"
+        "error_x": {
+          "array": {
+            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_x_array=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "mode": {
-            "description": "Sets the shape of connector lines.",
-            "dflt": "between",
+          "arrayminus": {
+            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_x_arrayminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "color": {
+            "description": "Sets the stroke color of the error bars.",
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(error_x_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "copy_ystyle": {
             "editType": "plot",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_x_copy_ystyle=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "editType": "calc",
+          "role": "object",
+          "symmetric": {
+            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_x_symmetric=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "thickness": {
+            "description": "Sets the thickness (in px) of the error bars.",
+            "dflt": 2,
+            "editType": "style",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_x_thickness=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "traceref": {
+            "dflt": 0,
+            "editType": "style",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_x_traceref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "tracerefminus": {
+            "dflt": 0,
+            "editType": "style",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_x_tracerefminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "type": {
+            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "spanning",
-              "between"
+              "percent",
+              "constant",
+              "sqrt",
+              "data"
             ],
-            "magic_underscores": "fig.update_traces(connector_mode=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "magic_underscores": "fig.update_traces(error_x_type=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "value": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_x_value=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "valueminus": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_x_valueminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "role": "object",
           "visible": {
-            "description": "Determines if connector lines are drawn. ",
-            "dflt": true,
+            "description": "Determines whether or not this set of error bars is visible.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_x_visible=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "width": {
+            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
             "editType": "plot",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_x_width=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "magic_underscores": "fig.update_traces(error_x=dict(...), selector=dict(type='histogram'))"
+        },
+        "error_y": {
+          "array": {
+            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_y_array=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "arrayminus": {
+            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_y_arrayminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "color": {
+            "description": "Sets the stroke color of the error bars.",
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(error_y_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "editType": "calc",
+          "role": "object",
+          "symmetric": {
+            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
+            "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(connector_visible=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "magic_underscores": "fig.update_traces(error_y_symmetric=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "magic_underscores": "fig.update_traces(connector=dict(...), selector=dict(type='waterfall'))"
+          "thickness": {
+            "description": "Sets the thickness (in px) of the error bars.",
+            "dflt": 2,
+            "editType": "style",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_y_thickness=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "traceref": {
+            "dflt": 0,
+            "editType": "style",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_y_traceref=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "tracerefminus": {
+            "dflt": 0,
+            "editType": "style",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_y_tracerefminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "type": {
+            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "percent",
+              "constant",
+              "sqrt",
+              "data"
+            ],
+            "magic_underscores": "fig.update_traces(error_y_type=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "value": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_y_value=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "valueminus": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_y_valueminus=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "visible": {
+            "description": "Determines whether or not this set of error bars is visible.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_y_visible=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "width": {
+            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
+            "editType": "plot",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_y_width=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "magic_underscores": "fig.update_traces(error_y=dict(...), selector=dict(type='histogram'))"
         },
-        "constraintext": {
-          "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself.",
-          "dflt": "both",
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "inside",
-            "outside",
-            "both",
-            "none"
-          ],
-          "magic_underscores": "fig.update_traces(constraintext=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "increasing": {
+        "selected": {
           "editType": "style",
           "marker": {
             "color": {
-              "arrayOk": false,
-              "description": "Sets the marker color of all increasing values.",
+              "description": "Sets the marker color of selected points.",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(increasing_marker_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "editType": "style",
-            "line": {
-              "color": {
-                "arrayOk": false,
-                "description": "Sets the line color of all increasing values.",
-                "editType": "style",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(increasing_marker_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-              },
+            "opacity": {
+              "description": "Sets the marker opacity of selected points.",
               "editType": "style",
-              "role": "object",
-              "width": {
-                "arrayOk": false,
-                "description": "Sets the line width of all increasing values.",
-                "dflt": 0,
-                "editType": "style",
-                "min": 0,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(increasing_marker_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-              },
-              "magic_underscores": "fig.update_traces(increasing_marker_line=dict(...), selector=dict(type='waterfall'))"
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(increasing_marker=dict(...), selector=dict(type='waterfall'))"
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='histogram'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(increasing=dict(...), selector=dict(type='waterfall'))"
+          "textfont": {
+            "color": {
+              "description": "Sets the text font color of selected points.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(selected_textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "editType": "style",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(selected_textfont=dict(...), selector=dict(type='histogram'))"
+          },
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='histogram'))"
         },
-        "decreasing": {
+        "unselected": {
           "editType": "style",
           "marker": {
             "color": {
-              "arrayOk": false,
-              "description": "Sets the marker color of all decreasing values.",
+              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(decreasing_marker_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "editType": "style",
-            "line": {
-              "color": {
-                "arrayOk": false,
-                "description": "Sets the line color of all decreasing values.",
-                "editType": "style",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(decreasing_marker_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-              },
+            "opacity": {
+              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
               "editType": "style",
-              "role": "object",
-              "width": {
-                "arrayOk": false,
-                "description": "Sets the line width of all decreasing values.",
-                "dflt": 0,
-                "editType": "style",
-                "min": 0,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(decreasing_marker_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-              },
-              "magic_underscores": "fig.update_traces(decreasing_marker_line=dict(...), selector=dict(type='waterfall'))"
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(decreasing_marker=dict(...), selector=dict(type='waterfall'))"
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='histogram'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(decreasing=dict(...), selector=dict(type='waterfall'))"
+          "textfont": {
+            "color": {
+              "description": "Sets the text font color of unselected points, applied only when a selection exists.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(unselected_textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+            },
+            "editType": "style",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(unselected_textfont=dict(...), selector=dict(type='histogram'))"
+          },
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='histogram'))"
+        },
+        "cliponaxis": {
+          "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.",
+          "dflt": true,
+          "editType": "plot",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(cliponaxis=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+        },
+        "constraintext": {
+          "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself.",
+          "dflt": "both",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "inside",
+            "outside",
+            "both",
+            "none"
+          ],
+          "magic_underscores": "fig.update_traces(constraintext=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+        },
+        "cumulative": {
+          "currentbin": {
+            "description": "Only applies if cumulative is enabled. Sets whether the current bin is included, excluded, or has half of its value included in the current cumulative value. *include* is the default for compatibility with various other tools, however it introduces a half-bin bias to the results. *exclude* makes the opposite half-bin bias, and *half* removes it.",
+            "dflt": "include",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "include",
+              "exclude",
+              "half"
+            ],
+            "magic_underscores": "fig.update_traces(cumulative_currentbin=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "direction": {
+            "description": "Only applies if cumulative is enabled. If *increasing* (default) we sum all prior bins, so the result increases from left to right. If *decreasing* we sum later bins so the result decreases from left to right.",
+            "dflt": "increasing",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "increasing",
+              "decreasing"
+            ],
+            "magic_underscores": "fig.update_traces(cumulative_direction=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "editType": "calc",
+          "enabled": {
+            "description": "If true, display the cumulative distribution by summing the binned values. Use the `direction` and `centralbin` attributes to tune the accumulation method. Note: in this mode, the *density* `histnorm` settings behave the same as their equivalents without *density*: ** and *density* both rise to the number of data points, and *probability* and *probability density* both rise to the number of sample points.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(cumulative_enabled=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(cumulative=dict(...), selector=dict(type='histogram'))"
         },
         "hoverlabel": {
           "align": {
@@ -45796,36 +37539,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "editType": "none",
           "font": {
@@ -45833,12 +37561,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -45849,12 +37572,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -45870,12 +37588,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "role": "object",
             "shadow": {
@@ -45884,24 +37597,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "style": {
               "arrayOk": true,
@@ -45913,12 +37616,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -45932,12 +37630,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "variant": {
               "arrayOk": true,
@@ -45953,12 +37646,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
             "weight": {
               "arrayOk": true,
@@ -45972,14 +37660,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='waterfall'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='histogram'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -45988,12 +37671,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "role": "object",
           "showarrow": {
@@ -46001,9 +37679,9 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='waterfall'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='histogram'))"
         },
         "insidetextanchor": {
           "description": "Determines if texts are kept at center or start/end points in `textposition` *inside* mode.",
@@ -46015,41 +37693,28 @@
             "middle",
             "start"
           ],
-          "magic_underscores": "fig.update_traces(insidetextanchor=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          "magic_underscores": "fig.update_traces(insidetextanchor=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "insidetextfont": {
           "color": {
-            "arrayOk": true,
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "description": "Sets the font used for `text` lying inside the bar.",
-          "editType": "calc",
+          "editType": "plot",
           "family": {
-            "arrayOk": true,
             "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "calc",
+            "editType": "plot",
             "noBlank": true,
             "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "lineposition": {
-            "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "none"
             ],
@@ -46059,61 +37724,37 @@
               "through"
             ],
             "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "role": "object",
           "shadow": {
-            "arrayOk": true,
             "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "size": {
-            "arrayOk": true,
-            "editType": "calc",
+            "editType": "plot",
             "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "style": {
-            "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
               "italic"
             ],
-            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "textcase": {
-            "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -46121,18 +37762,12 @@
               "upper",
               "lower"
             ],
-            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "variant": {
-            "arrayOk": true,
             "description": "Sets the variant of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -46142,18 +37777,12 @@
               "petite-caps",
               "unicase"
             ],
-            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "weight": {
-            "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "normal",
               "bold"
@@ -46161,48 +37790,30 @@
             "max": 1000,
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='waterfall'))"
+          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='histogram'))"
         },
         "outsidetextfont": {
           "color": {
-            "arrayOk": true,
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "description": "Sets the font used for `text` lying outside the bar.",
-          "editType": "calc",
+          "editType": "plot",
           "family": {
-            "arrayOk": true,
             "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "calc",
+            "editType": "plot",
             "noBlank": true,
             "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "lineposition": {
-            "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "none"
             ],
@@ -46212,61 +37823,37 @@
               "through"
             ],
             "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "role": "object",
           "shadow": {
-            "arrayOk": true,
             "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "size": {
-            "arrayOk": true,
-            "editType": "calc",
+            "editType": "plot",
             "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "style": {
-            "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
               "italic"
             ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "textcase": {
-            "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -46274,18 +37861,12 @@
               "upper",
               "lower"
             ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "variant": {
-            "arrayOk": true,
             "description": "Sets the variant of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -46295,18 +37876,12 @@
               "petite-caps",
               "unicase"
             ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
           "weight": {
-            "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "normal",
               "bold"
@@ -46314,100 +37889,92 @@
             "max": 1000,
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram'))"
           },
-          "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='waterfall'))"
+          "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='histogram'))"
         },
-        "totals": {
-          "editType": "style",
-          "marker": {
-            "color": {
-              "arrayOk": false,
-              "description": "Sets the marker color of all intermediate sums and total values.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(totals_marker_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-            },
-            "editType": "style",
-            "line": {
-              "color": {
-                "arrayOk": false,
-                "description": "Sets the line color of all intermediate sums and total values.",
-                "editType": "style",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(totals_marker_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-              },
-              "editType": "style",
-              "role": "object",
-              "width": {
-                "arrayOk": false,
-                "description": "Sets the line width of all intermediate sums and total values.",
-                "dflt": 0,
-                "editType": "style",
-                "min": 0,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(totals_marker_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-              },
-              "magic_underscores": "fig.update_traces(totals_marker_line=dict(...), selector=dict(type='waterfall'))"
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(totals_marker=dict(...), selector=dict(type='waterfall'))"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(totals=dict(...), selector=dict(type='waterfall'))"
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='histogram'))"
+        },
+        "ycalendar": {
+          "description": "Sets the calendar system to use with `y` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='waterfall'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='histogram'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='waterfall'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='histogram'))"
       },
       "categories": [
         "bar-like",
         "cartesian",
         "svg",
+        "bar",
+        "histogram",
         "oriented",
-        "showLegend",
-        "zoomScale"
+        "errorBarsOK",
+        "showLegend"
       ],
       "layoutAttributes": {
-        "waterfallgap": {
+        "barcornerradius": {
+          "description": "Sets the rounding of bar corners. May be an integer number of pixels, or a percentage of bar width (as a string ending in %).",
+          "editType": "calc",
+          "valType": "any"
+        },
+        "bargap": {
           "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates.",
           "editType": "calc",
           "max": 1,
           "min": 0,
           "valType": "number"
         },
-        "waterfallgroupgap": {
+        "bargroupgap": {
           "description": "Sets the gap (in plot fraction) between bars of the same location coordinate.",
           "dflt": 0,
           "editType": "calc",
@@ -46415,37 +37982,50 @@
           "min": 0,
           "valType": "number"
         },
-        "waterfallmode": {
-          "description": "Determines how bars at the same location coordinate are displayed on the graph. With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to reduce *opacity* to see multiple bars.",
+        "barmode": {
+          "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *relative*, the bars are stacked on top of one another, with negative values below the axis, positive values above With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to reduce *opacity* to see multiple bars.",
           "dflt": "group",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
+            "stack",
             "group",
-            "overlay"
+            "overlay",
+            "relative"
+          ]
+        },
+        "barnorm": {
+          "description": "Sets the normalization for bar traces on the graph. With *fraction*, the value of each bar is divided by the sum of all values at that location coordinate. *percent* is the same but multiplied by 100 to show percentages.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "",
+            "fraction",
+            "percent"
           ]
         }
       },
       "meta": {
-        "description": "Draws waterfall trace which is useful graph to displays the contribution of various elements (either positive or negative) in a bar chart. The data visualized by the span of the bars is set in `y` if `orientation` is set to *v* (the default) and the labels are set in `x`. By setting `orientation` to *h*, the roles are interchanged."
+        "description": "The sample data from which statistics are computed is set in `x` for vertically spanning histograms and in `y` for horizontally spanning histograms. Binning options are set `xbins` and `ybins` respectively if no aggregation data is provided."
       },
-      "type": "waterfall"
+      "type": "histogram"
     },
-    "funnel": {
+    "histogram2d": {
       "animatable": false,
       "attributes": {
-        "type": "funnel",
+        "type": "histogram2d",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -46457,35 +38037,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
+          "dflt": false,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -46493,7 +38073,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -46503,7 +38083,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -46518,7 +38098,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "role": "object",
             "shadow": {
@@ -46526,13 +38106,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -46543,7 +38123,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -46556,7 +38136,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -46571,7 +38151,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -46584,9 +38164,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='histogram2d'))"
           },
           "role": "object",
           "text": {
@@ -46594,16 +38174,16 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='histogram2d'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "opacity": {
           "description": "Sets the opacity of the trace.",
@@ -46612,161 +38192,65 @@
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "zorder": {
-          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
-          "dflt": 0,
-          "editType": "plot",
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "x": {
-          "description": "Sets the x coordinates.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x0": {
-          "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
-          "dflt": 0,
+          "description": "Sets the sample data to be binned on the x axis.",
           "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "dx": {
-          "description": "Sets the x coordinate step. See `x0` for more info.",
-          "dflt": 1,
-          "editType": "calc",
+        "xgap": {
+          "description": "Sets the horizontal gap (in pixels) between bricks.",
+          "dflt": 0,
+          "editType": "plot",
+          "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(dx=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(xgap=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "y": {
-          "description": "Sets the y coordinates.",
+          "description": "Sets the sample data to be binned on the y axis.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "y0": {
-          "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
+        "ygap": {
+          "description": "Sets the vertical gap (in pixels) between bricks.",
           "dflt": 0,
-          "editType": "calc+clearAxisTypes",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "dy": {
-          "description": "Sets the y coordinate step. See `y0` for more info.",
-          "dflt": 1,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(dy=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "width": {
-          "arrayOk": false,
-          "description": "Sets the bar width (in position axis units).",
-          "dflt": null,
-          "editType": "calc",
+          "editType": "plot",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "offset": {
-          "arrayOk": false,
-          "description": "Shifts the position where the bar is drawn (in position axis units). In *group* barmode, traces that set *offset* will be excluded and drawn in *overlay* mode instead.",
-          "dflt": null,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(offset=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "text": {
-          "arrayOk": true,
-          "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ygap=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "textposition": {
-          "arrayOk": true,
-          "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed), unless there is another bar stacked on this one, then the text gets pushed inside. *auto* tries to position `text` inside the bar, but if the bar is too small and no bar is stacked on this one the text is moved outside. If *none*, no text appears.",
-          "dflt": "auto",
+        "z": {
+          "description": "Sets the aggregation data.",
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "inside",
-            "outside",
-            "auto",
-            "none"
-          ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "texttemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `percentInitial`, `percentPrevious`, `percentTotal`, `label` and `value`.",
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `z`",
           "dflt": "",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "texttemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -46775,457 +38259,799 @@
             "skip"
           ],
           "flags": [
-            "name",
             "x",
             "y",
+            "z",
             "text",
-            "percent initial",
-            "percent previous",
-            "percent total"
+            "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `percentInitial`, `percentPrevious` and `percentTotal`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `z` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
         "yaxis": {
           "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
           "dflt": "y",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "orientation": {
-          "description": "Sets the orientation of the funnels. With *v* (*h*), the value of the each bar spans along the vertical (horizontal). By default funnels are tend to be oriented horizontally; unless only *y* array is presented or orientation is set to *v*. Also regarding graphs including only 'horizontal' funnels, *autorange* on the *y-axis* are set to *reversed*.",
-          "editType": "calc+clearAxisTypes",
+        "coloraxis": {
+          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+          "dflt": null,
+          "editType": "calc",
+          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "histfunc": {
+          "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.",
+          "dflt": "count",
+          "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "v",
-            "h"
+            "count",
+            "sum",
+            "avg",
+            "min",
+            "max"
           ],
-          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(histfunc=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "alignmentgroup": {
-          "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
+        "histnorm": {
+          "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).",
           "dflt": "",
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "enumerated",
+          "values": [
+            "",
+            "percent",
+            "probability",
+            "density",
+            "probability density"
+          ],
+          "magic_underscores": "fig.update_traces(histnorm=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "offsetgroup": {
-          "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
-          "dflt": "",
+        "nbinsx": {
+          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `xbins.size` is provided.",
+          "dflt": 0,
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "min": 0,
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(nbinsx=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "xperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+        "nbinsy": {
+          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `ybins.size` is provided.",
           "dflt": 0,
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "min": 0,
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(nbinsy=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "xperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
-          "dflt": "middle",
+        "autobinx": {
+          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobinx` is not needed. However, we accept `autobinx: true` or `false` and will update `xbins` accordingly before deleting `autobinx` from the trace.",
+          "dflt": null,
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "start",
-            "middle",
-            "end"
-          ],
-          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autobinx=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "xperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+        "autobiny": {
+          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobiny` is not needed. However, we accept `autobiny: true` or `false` and will update `ybins` accordingly before deleting `autobiny` from the trace.",
+          "dflt": null,
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autobiny=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "yperiod": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the y axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
-          "dflt": 0,
+        "bingroup": {
+          "description": "Set the `xbingroup` and `ybingroup` default prefix For example, setting a `bingroup` of *1* on two histogram2d traces will make them their x-bins and y-bins match separately.",
+          "dflt": "",
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(yperiod=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(bingroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "yperiodalignment": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the y axis.",
-          "dflt": "middle",
+        "xbingroup": {
+          "description": "Set a group of histogram traces which will have compatible x-bin settings. Using `xbingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible x-bin settings. Note that the same `xbingroup` value can be used to set (1D) histogram `bingroup`",
+          "dflt": "",
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "start",
-            "middle",
-            "end"
-          ],
-          "magic_underscores": "fig.update_traces(yperiodalignment=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xbingroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "yperiod0": {
-          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the y0 axis. When `y0period` is round number of weeks, the `y0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+        "xbins": {
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(yperiod0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "end": {
+            "description": "Sets the end value for the x axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_end=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "role": "object",
+          "size": {
+            "description": "Sets the size of each x axis bin. Default behavior: If `nbinsx` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsx` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "start": {
+            "description": "Sets the starting value for the x axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_start=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "magic_underscores": "fig.update_traces(xbins=dict(...), selector=dict(type='histogram2d'))"
+        },
+        "ybingroup": {
+          "description": "Set a group of histogram traces which will have compatible y-bin settings. Using `ybingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible y-bin settings. Note that the same `ybingroup` value can be used to set (1D) histogram `bingroup`",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(ybingroup=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "ybins": {
+          "editType": "calc",
+          "end": {
+            "description": "Sets the end value for the y axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_end=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "role": "object",
+          "size": {
+            "description": "Sets the size of each y axis bin. Default behavior: If `nbinsy` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsy` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "start": {
+            "description": "Sets the starting value for the y axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_start=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "magic_underscores": "fig.update_traces(ybins=dict(...), selector=dict(type='histogram2d'))"
         },
         "marker": {
-          "autocolorscale": {
-            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-            "dflt": true,
+          "color": {
+            "description": "Sets the aggregation data.",
             "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "editType": "calc",
+          "role": "object",
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='histogram2d'))"
+        },
+        "textfont": {
+          "color": {
+            "dflt": "auto",
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "description": "Sets the text font.",
+          "editType": "plot",
+          "family": {
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+            "editType": "plot",
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "lineposition": {
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "plot",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "role": "object",
+          "shadow": {
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "size": {
+            "dflt": "auto",
+            "editType": "plot",
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "style": {
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "textcase": {
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "variant": {
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "weight": {
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "plot",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='histogram2d'))"
+        },
+        "colorbar": {
+          "bgcolor": {
+            "description": "Sets the color of padded area.",
+            "dflt": "rgba(0,0,0,0)",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "bordercolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "borderwidth": {
+            "description": "Sets the width (in px) or the border enclosing this color bar.",
+            "dflt": 0,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "dtick": {
+            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+            "editType": "colorbars",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "editType": "colorbars",
+          "exponentformat": {
+            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+            "dflt": "B",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "none",
+              "e",
+              "E",
+              "power",
+              "SI",
+              "B",
+              "SI extended"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "labelalias": {
+            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+            "dflt": false,
+            "editType": "colorbars",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "len": {
+            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "lenmode": {
+            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+            "dflt": "fraction",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "minexponent": {
+            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+            "dflt": 3,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "nticks": {
+            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+            "dflt": 0,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "orientation": {
+            "description": "Sets the orientation of the colorbar.",
+            "dflt": "v",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "h",
+              "v"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "outlinecolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "outlinewidth": {
+            "description": "Sets the width (in px) of the axis line.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "role": "object",
+          "separatethousands": {
+            "description": "If \"true\", even 4-digit integers are separated",
+            "dflt": false,
+            "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "cauto": {
-            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
+          "showexponent": {
+            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "showticklabels": {
+            "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
+            "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "cmax": {
-            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
-            "dflt": null,
-            "editType": "plot",
-            "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "showtickprefix": {
+            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "cmid": {
-            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
+          "showticksuffix": {
+            "description": "Same as `showtickprefix` but for tick suffixes.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "thickness": {
+            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+            "dflt": 30,
+            "editType": "colorbars",
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "cmin": {
-            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
-            "dflt": null,
-            "editType": "plot",
+          "thicknessmode": {
+            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+            "dflt": "pixels",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "tick0": {
+            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+            "editType": "colorbars",
             "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "color": {
-            "arrayOk": true,
-            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "tickangle": {
+            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+            "dflt": "auto",
+            "editType": "colorbars",
+            "valType": "angle",
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "coloraxis": {
-            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-            "dflt": null,
-            "editType": "calc",
-            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-            "valType": "subplotid",
-            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "tickcolor": {
+            "description": "Sets the tick color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "colorbar": {
-            "bgcolor": {
-              "description": "Sets the color of padded area.",
-              "dflt": "rgba(0,0,0,0)",
-              "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "bordercolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
+          "tickfont": {
+            "color": {
               "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "borderwidth": {
-              "description": "Sets the width (in px) or the border enclosing this color bar.",
-              "dflt": 0,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "dtick": {
-              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-              "editType": "colorbars",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
+            "description": "Sets the color bar's tick label font",
             "editType": "colorbars",
-            "exponentformat": {
-              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-              "dflt": "B",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "none",
-                "e",
-                "E",
-                "power",
-                "SI",
-                "B",
-                "SI extended"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "labelalias": {
-              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-              "dflt": false,
-              "editType": "colorbars",
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "len": {
-              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-              "dflt": 1,
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
               "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "lenmode": {
-              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-              "dflt": "fraction",
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
               "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
+              "extras": [
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "minexponent": {
-              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-              "dflt": 3,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "nticks": {
-              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-              "dflt": 0,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "orientation": {
-              "description": "Sets the orientation of the colorbar.",
-              "dflt": "v",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "h",
-                "v"
+              "flags": [
+                "under",
+                "over",
+                "through"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "outlinecolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
               "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "outlinewidth": {
-              "description": "Sets the width (in px) of the axis line.",
-              "dflt": 1,
+            "size": {
               "editType": "colorbars",
-              "min": 0,
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "role": "object",
-            "separatethousands": {
-              "description": "If \"true\", even 4-digit integers are separated",
-              "dflt": false,
-              "editType": "colorbars",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "showexponent": {
-              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-              "dflt": "all",
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "showticklabels": {
-              "description": "Determines whether or not the tick labels are drawn.",
-              "dflt": true,
-              "editType": "colorbars",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "showtickprefix": {
-              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-              "dflt": "all",
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "showticksuffix": {
-              "description": "Same as `showtickprefix` but for tick suffixes.",
-              "dflt": "all",
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "thickness": {
-              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-              "dflt": 30,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "thicknessmode": {
-              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-              "dflt": "pixels",
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
               "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
+              "extras": [
+                "normal",
+                "bold"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "tick0": {
-              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-              "editType": "colorbars",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "tickangle": {
-              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-              "dflt": "auto",
-              "editType": "colorbars",
-              "valType": "angle",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='histogram2d'))"
+          },
+          "tickformat": {
+            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "tickformatstops": {
+            "items": {
+              "tickformatstop": {
+                "dtickrange": {
+                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                  "editType": "colorbars",
+                  "items": [
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    },
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    }
+                  ],
+                  "valType": "info_array"
+                },
+                "editType": "colorbars",
+                "enabled": {
+                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                  "dflt": true,
+                  "editType": "colorbars",
+                  "valType": "boolean"
+                },
+                "name": {
+                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "role": "object",
+                "templateitemname": {
+                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "value": {
+                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                  "dflt": "",
+                  "editType": "colorbars",
+                  "valType": "string"
+                }
+              }
             },
-            "tickcolor": {
-              "description": "Sets the tick color.",
-              "dflt": "#444",
-              "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "role": "object",
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='histogram2d'))"
+          },
+          "ticklabeloverflow": {
+            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "allow",
+              "hide past div",
+              "hide past domain"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "ticklabelposition": {
+            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+            "dflt": "outside",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              "outside top",
+              "inside top",
+              "outside left",
+              "inside left",
+              "outside right",
+              "inside right",
+              "outside bottom",
+              "inside bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "ticklabelstep": {
+            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "ticklen": {
+            "description": "Sets the tick length (in px).",
+            "dflt": 5,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "tickmode": {
+            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "tickfont": {
+            "valType": "enumerated",
+            "values": [
+              "auto",
+              "linear",
+              "array"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "tickprefix": {
+            "description": "Sets a tick label prefix.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "ticks": {
+            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              ""
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "ticksuffix": {
+            "description": "Sets a tick label suffix.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "ticktext": {
+            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "tickvals": {
+            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "tickwidth": {
+            "description": "Sets the tick width (in px).",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "title": {
+            "editType": "colorbars",
+            "font": {
               "color": {
                 "editType": "colorbars",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
-              "description": "Sets the color bar's tick label font",
+              "description": "Sets this color bar's title font.",
               "editType": "colorbars",
               "family": {
                 "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
@@ -47233,7 +39059,7 @@
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -47248,7 +39074,7 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
               "role": "object",
               "shadow": {
@@ -47256,13 +39082,13 @@
                 "dflt": "none",
                 "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
               "size": {
                 "editType": "colorbars",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -47273,7 +39099,7 @@
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -47281,1089 +39107,965 @@
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='funnel'))"
-            },
-            "tickformat": {
-              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "tickformatstops": {
-              "items": {
-                "tickformatstop": {
-                  "dtickrange": {
-                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                    "editType": "colorbars",
-                    "items": [
-                      {
-                        "editType": "colorbars",
-                        "valType": "any"
-                      },
-                      {
-                        "editType": "colorbars",
-                        "valType": "any"
-                      }
-                    ],
-                    "valType": "info_array"
-                  },
-                  "editType": "colorbars",
-                  "enabled": {
-                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                    "dflt": true,
-                    "editType": "colorbars",
-                    "valType": "boolean"
-                  },
-                  "name": {
-                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                    "editType": "colorbars",
-                    "valType": "string"
-                  },
-                  "role": "object",
-                  "templateitemname": {
-                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                    "editType": "colorbars",
-                    "valType": "string"
-                  },
-                  "value": {
-                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                    "dflt": "",
-                    "editType": "colorbars",
-                    "valType": "string"
-                  }
-                }
-              },
-              "role": "object",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='funnel'))"
-            },
-            "ticklabeloverflow": {
-              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "allow",
-                "hide past div",
-                "hide past domain"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ticklabelposition": {
-              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-              "dflt": "outside",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                "outside top",
-                "inside top",
-                "outside left",
-                "inside left",
-                "outside right",
-                "inside right",
-                "outside bottom",
-                "inside bottom"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ticklabelstep": {
-              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-              "dflt": 1,
-              "editType": "colorbars",
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ticklen": {
-              "description": "Sets the tick length (in px).",
-              "dflt": 5,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "tickmode": {
-              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-              "editType": "colorbars",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "valType": "enumerated",
-              "values": [
-                "auto",
-                "linear",
-                "array"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "tickprefix": {
-              "description": "Sets a tick label prefix.",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ticks": {
-              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                ""
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ticksuffix": {
-              "description": "Sets a tick label suffix.",
-              "dflt": "",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ticktext": {
-              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-              "editType": "colorbars",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickvals": {
-              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-              "editType": "colorbars",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickwidth": {
-              "description": "Sets the tick width (in px).",
-              "dflt": 1,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "title": {
-              "editType": "colorbars",
-              "font": {
-                "color": {
-                  "editType": "colorbars",
-                  "valType": "color",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "description": "Sets this color bar's title font.",
-                "editType": "colorbars",
-                "family": {
-                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                  "editType": "colorbars",
-                  "noBlank": true,
-                  "strict": true,
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "lineposition": {
-                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                  "dflt": "none",
-                  "editType": "colorbars",
-                  "extras": [
-                    "none"
-                  ],
-                  "flags": [
-                    "under",
-                    "over",
-                    "through"
-                  ],
-                  "valType": "flaglist",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "role": "object",
-                "shadow": {
-                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                  "dflt": "none",
-                  "editType": "colorbars",
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "size": {
-                  "editType": "colorbars",
-                  "min": 1,
-                  "valType": "number",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "style": {
-                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "italic"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "textcase": {
-                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "word caps",
-                    "upper",
-                    "lower"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "variant": {
-                  "description": "Sets the variant of the font.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "small-caps",
-                    "all-small-caps",
-                    "all-petite-caps",
-                    "petite-caps",
-                    "unicase"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "weight": {
-                  "description": "Sets the weight (or boldness) of the font.",
-                  "dflt": "normal",
-                  "editType": "colorbars",
-                  "extras": [
-                    "normal",
-                    "bold"
-                  ],
-                  "max": 1000,
-                  "min": 1,
-                  "valType": "integer",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-                },
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='funnel'))"
-              },
-              "role": "object",
-              "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "right",
-                  "top",
-                  "bottom"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "text": {
-                "description": "Sets the title of the color bar.",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='funnel'))"
-            },
-            "x": {
-              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-              "editType": "colorbars",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "xanchor": {
-              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "left",
-                "center",
-                "right"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "xpad": {
-              "description": "Sets the amount of padding (in px) along the x direction.",
-              "dflt": 10,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "xref": {
-              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-              "dflt": "paper",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "y": {
-              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-              "editType": "colorbars",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "yanchor": {
-              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "top",
-                "middle",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "ypad": {
-              "description": "Sets the amount of padding (in px) along the y direction.",
-              "dflt": 10,
-              "editType": "colorbars",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "yref": {
-              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-              "dflt": "paper",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='funnel'))"
-          },
-          "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "autocolorscale": false,
-              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "valType": "colorscale",
-            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "calc",
-          "line": {
-            "autocolorscale": {
-              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "cauto": {
-              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "cmax": {
-              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
-              "dflt": null,
-              "editType": "plot",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "cmid": {
-              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "cmin": {
-              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
-              "dflt": null,
-              "editType": "plot",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "coloraxis": {
-              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-              "dflt": null,
-              "editType": "calc",
-              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-              "valType": "subplotid",
-              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "autocolorscale": false,
-                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
               },
-              "valType": "colorscale",
-              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "editType": "calc",
-            "reversescale": {
-              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
-              "dflt": false,
-              "editType": "plot",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='histogram2d'))"
             },
             "role": "object",
-            "width": {
-              "arrayOk": true,
-              "description": "Sets the width (in px) of the lines bounding the marker points.",
-              "dflt": 0,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "side": {
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "right",
+                "top",
+                "bottom"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
+            "text": {
+              "description": "Sets the title of the color bar.",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
             },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='histogram2d'))"
           },
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the opacity of the bars.",
-            "dflt": 1,
-            "editType": "style",
-            "max": 1,
+          "x": {
+            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+            "editType": "colorbars",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "xanchor": {
+            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "center",
+              "right"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+          },
+          "xpad": {
+            "description": "Sets the amount of padding (in px) along the x direction.",
+            "dflt": 10,
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
+          "xref": {
+            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "container",
+              "paper"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "reversescale": {
-            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
-            "dflt": false,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "y": {
+            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+            "editType": "colorbars",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "role": "object",
-          "showscale": {
-            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "yanchor": {
+            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "top",
+              "middle",
+              "bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='funnel'))"
-        },
-        "textangle": {
-          "description": "Sets the angle of the tick labels with respect to the bar. For example, a `tickangle` of -90 draws the tick labels vertically. With *auto* the texts may automatically be rotated to fit with the maximum size in bars.",
-          "dflt": 0,
-          "editType": "plot",
-          "valType": "angle",
-          "magic_underscores": "fig.update_traces(textangle=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "textfont": {
-          "color": {
-            "arrayOk": true,
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "ypad": {
+            "description": "Sets the amount of padding (in px) along the y direction.",
+            "dflt": 10,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+          "yref": {
+            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "container",
+              "paper"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "description": "Sets the font used for `text`.",
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='histogram2d'))"
+        },
+        "autocolorscale": {
+          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+          "dflt": false,
           "editType": "calc",
-          "family": {
-            "arrayOk": true,
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "colorscale": {
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "autocolorscale": false,
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "lineposition": {
-            "arrayOk": true,
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "calc",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "colorscale",
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "showscale": {
+          "description": "Determines whether or not a colorbar is displayed for this trace.",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "reversescale": {
+          "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
+          "dflt": false,
+          "editType": "plot",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "zauto": {
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
+          "dflt": true,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "zhoverformat": {
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "zmax": {
+          "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
+          "dflt": null,
+          "editType": "plot",
+          "impliedEdits": {
+            "zauto": false,
+            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "role": "object",
-          "shadow": {
-            "arrayOk": true,
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "zmid": {
+          "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "zmin": {
+          "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
+          "dflt": null,
+          "editType": "plot",
+          "impliedEdits": {
+            "zauto": false,
+            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "size": {
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "zsmooth": {
+          "description": "Picks a smoothing algorithm use to smooth `z` data.",
+          "dflt": false,
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "fast",
+            "best",
+            false
+          ],
+          "magic_underscores": "fig.update_traces(zsmooth=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "hoverlabel": {
+          "align": {
             "arrayOk": true,
-            "editType": "calc",
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
+            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
+            "dflt": "auto",
             "editType": "none",
-            "valType": "string"
-          },
-          "style": {
-            "arrayOk": true,
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "italic"
+              "left",
+              "right",
+              "auto"
             ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "textcase": {
+          "bgcolor": {
             "arrayOk": true,
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
+            "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
-            "valType": "string"
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "variant": {
+          "bordercolor": {
             "arrayOk": true,
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "description": "Sets the border color of the hover labels for this trace.",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
+          "editType": "none",
+          "font": {
+            "color": {
+              "arrayOk": true,
+              "editType": "none",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "description": "Sets the font used in hover labels.",
             "editType": "none",
-            "valType": "string"
+            "family": {
+              "arrayOk": true,
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "none",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "lineposition": {
+              "arrayOk": true,
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "none",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "role": "object",
+            "shadow": {
+              "arrayOk": true,
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "none",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "size": {
+              "arrayOk": true,
+              "editType": "none",
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "style": {
+              "arrayOk": true,
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "textcase": {
+              "arrayOk": true,
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "variant": {
+              "arrayOk": true,
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "weight": {
+              "arrayOk": true,
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "none",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+            },
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='histogram2d'))"
           },
-          "weight": {
+          "namelength": {
             "arrayOk": true,
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "calc",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
+          "role": "object",
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
             "editType": "none",
-            "valType": "string"
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
           },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='histogram2d'))"
         },
-        "textinfo": {
-          "arrayOk": false,
-          "description": "Determines which trace information appear on the graph. In the case of having multiple funnels, percentages & totals are computed separately (per trace).",
-          "editType": "plot",
-          "extras": [
-            "none"
-          ],
-          "flags": [
-            "label",
-            "text",
-            "percent initial",
-            "percent previous",
-            "percent total",
-            "value"
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
           ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(textinfo=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+        "ycalendar": {
+          "description": "Sets the calendar system to use with `y` date data.",
+          "dflt": "gregorian",
           "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='histogram2d'))"
         },
-        "cliponaxis": {
-          "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.",
-          "dflt": true,
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='histogram2d'))"
+      },
+      "categories": [
+        "cartesian",
+        "svg",
+        "2dMap",
+        "histogram",
+        "showLegend"
+      ],
+      "meta": {
+        "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a heatmap.",
+        "hrName": "histogram_2d"
+      },
+      "type": "histogram2d"
+    },
+    "histogram2dcontour": {
+      "animatable": false,
+      "attributes": {
+        "type": "histogram2dcontour",
+        "name": {
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "uid": {
+          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            true,
+            false,
+            "legendonly"
+          ],
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cliponaxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "connector": {
-          "editType": "plot",
-          "fillcolor": {
-            "description": "Sets the fill color.",
-            "editType": "style",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(connector_fillcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "line": {
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "legendgrouptitle": {
+          "editType": "style",
+          "font": {
             "color": {
-              "description": "Sets the line color.",
-              "dflt": "#444",
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(connector_line_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "dash": {
-              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
-              "dflt": "solid",
+            "description": "Sets this legend group's title font.",
+            "editType": "style",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
               "editType": "style",
+              "noBlank": true,
+              "strict": true,
               "valType": "string",
-              "values": [
-                "solid",
-                "dot",
-                "dash",
-                "longdash",
-                "dashdot",
-                "longdashdot"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "style",
+              "extras": [
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(connector_line_dash=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "editType": "style",
             "role": "object",
-            "width": {
-              "description": "Sets the line width (in px).",
-              "dflt": 0,
-              "editType": "plot",
-              "min": 0,
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "size": {
+              "editType": "style",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(connector_line_width=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "magic_underscores": "fig.update_traces(connector_line=dict(...), selector=dict(type='funnel'))"
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='histogram2dcontour'))"
           },
           "role": "object",
-          "visible": {
-            "description": "Determines if connector regions and lines are drawn.",
-            "dflt": true,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(connector_visible=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(connector=dict(...), selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='histogram2dcontour'))"
         },
-        "constraintext": {
-          "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself.",
-          "dflt": "both",
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "x": {
+          "description": "Sets the sample data to be binned on the x axis.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "y": {
+          "description": "Sets the sample data to be binned on the y axis.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "z": {
+          "description": "Sets the aggregation data.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "texttemplate": {
+          "description": "For this trace it only has an effect if `coloring` is set to *heatmap*. Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `x`, `y`, `z` and `text`.",
+          "dflt": "",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "texttemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "hoverinfo": {
+          "arrayOk": true,
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "dflt": "all",
+          "editType": "none",
+          "extras": [
+            "all",
+            "none",
+            "skip"
+          ],
+          "flags": [
+            "x",
+            "y",
+            "z",
+            "text",
+            "name"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `z` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "hovertemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "meta": {
+          "arrayOk": true,
+          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "customdata": {
+          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "xaxis": {
+          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
+          "dflt": "x",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "yaxis": {
+          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
+          "dflt": "y",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "coloraxis": {
+          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+          "dflt": null,
+          "editType": "calc",
+          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "histfunc": {
+          "description": "Specifies the binning function used for this histogram trace. If *count*, the histogram values are computed by counting the number of values lying inside each bin. If *sum*, *avg*, *min*, *max*, the histogram values are computed using the sum, the average, the minimum or the maximum of the values lying inside each bin respectively.",
+          "dflt": "count",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "inside",
-            "outside",
-            "both",
-            "none"
+            "count",
+            "sum",
+            "avg",
+            "min",
+            "max"
           ],
-          "magic_underscores": "fig.update_traces(constraintext=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(histfunc=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "right",
-              "auto"
-            ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        "histnorm": {
+          "description": "Specifies the type of normalization used for this histogram trace. If **, the span of each bar corresponds to the number of occurrences (i.e. the number of data points lying inside the bins). If *percent* / *probability*, the span of each bar corresponds to the percentage / fraction of occurrences with respect to the total number of sample points (here, the sum of all bin HEIGHTS equals 100% / 1). If *density*, the span of each bar corresponds to the number of occurrences in a bin divided by the size of the bin interval (here, the sum of all bin AREAS equals the total number of sample points). If *probability density*, the area of each bar corresponds to the probability that an event will fall into the corresponding bin (here, the sum of all bin AREAS equals 1).",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "",
+            "percent",
+            "probability",
+            "density",
+            "probability density"
+          ],
+          "magic_underscores": "fig.update_traces(histnorm=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "nbinsx": {
+          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `xbins.size` is provided.",
+          "dflt": 0,
+          "editType": "calc",
+          "min": 0,
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(nbinsx=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "nbinsy": {
+          "description": "Specifies the maximum number of desired bins. This value will be used in an algorithm that will decide the optimal bin size such that the histogram best visualizes the distribution of the data. Ignored if `ybins.size` is provided.",
+          "dflt": 0,
+          "editType": "calc",
+          "min": 0,
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(nbinsy=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "autobinx": {
+          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobinx` is not needed. However, we accept `autobinx: true` or `false` and will update `xbins` accordingly before deleting `autobinx` from the trace.",
+          "dflt": null,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autobinx=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "autobiny": {
+          "description": "Obsolete: since v1.42 each bin attribute is auto-determined separately and `autobiny` is not needed. However, we accept `autobiny: true` or `false` and will update `ybins` accordingly before deleting `autobiny` from the trace.",
+          "dflt": null,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autobiny=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "bingroup": {
+          "description": "Set the `xbingroup` and `ybingroup` default prefix For example, setting a `bingroup` of *1* on two histogram2d traces will make them their x-bins and y-bins match separately.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(bingroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "xbingroup": {
+          "description": "Set a group of histogram traces which will have compatible x-bin settings. Using `xbingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible x-bin settings. Note that the same `xbingroup` value can be used to set (1D) histogram `bingroup`",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xbingroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "xbins": {
+          "editType": "calc",
+          "end": {
+            "description": "Sets the end value for the x axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_end=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+          "role": "object",
+          "size": {
+            "description": "Sets the size of each x axis bin. Default behavior: If `nbinsx` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsx` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "start": {
+            "description": "Sets the starting value for the x axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(xbins_start=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+          "magic_underscores": "fig.update_traces(xbins=dict(...), selector=dict(type='histogram2dcontour'))"
+        },
+        "ybingroup": {
+          "description": "Set a group of histogram traces which will have compatible y-bin settings. Using `ybingroup`, histogram2d and histogram2dcontour traces  (on axes of the same axis type) can have compatible y-bin settings. Note that the same `ybingroup` value can be used to set (1D) histogram `bingroup`",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(ybingroup=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "ybins": {
+          "editType": "calc",
+          "end": {
+            "description": "Sets the end value for the y axis bins. The last bin may not end exactly at this value, we increment the bin edge by `size` from `start` until we reach or exceed `end`. Defaults to the maximum data value. Like `start`, for dates use a date string, and for category data `end` is based on the category serial numbers.",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_end=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "bordercolor": {
-            "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "role": "object",
+          "size": {
+            "description": "Sets the size of each y axis bin. Default behavior: If `nbinsy` is 0 or omitted, we choose a nice round bin size such that the number of bins is about the same as the typical number of samples in each bin. If `nbinsy` is provided, we choose a nice round bin size giving no more than that many bins. For date data, use milliseconds or *M<n>* for months, as in `axis.dtick`. For category data, the number of categories to bin together (always defaults to 1). ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+          "start": {
+            "description": "Sets the starting value for the y axis bins. Defaults to the minimum data value, shifted down if necessary to make nice round values and to remove ambiguous bin edges. For example, if most of the data is integers we shift the bin edges 0.5 down, so a `size` of 5 would have a default `start` of -0.5, so it is clear that 0-4 are in the first bin, 5-9 in the second, but continuous data gets a start of 0 and bins [0,5), [5,10) etc. Dates behave similarly, and `start` should be a date string. For category data, `start` is based on the category serial numbers, and defaults to -0.5. ",
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(ybins_start=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "editType": "none",
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "none",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "none",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "none",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "size": {
-              "arrayOk": true,
-              "editType": "none",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(ybins=dict(...), selector=dict(type='histogram2dcontour'))"
+        },
+        "marker": {
+          "color": {
+            "description": "Sets the aggregation data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "editType": "calc",
+          "role": "object",
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='histogram2dcontour'))"
+        },
+        "line": {
+          "color": {
+            "description": "Sets the color of the contour level. Has no effect if `contours.coloring` is set to *lines*.",
+            "editType": "style+colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+          "dash": {
+            "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+            "dflt": "solid",
+            "editType": "style",
+            "valType": "string",
+            "values": [
+              "solid",
+              "dot",
+              "dash",
+              "longdash",
+              "dashdot",
+              "longdashdot"
+            ],
+            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
+          "editType": "plot",
           "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "smoothing": {
+            "description": "Sets the amount of smoothing for the contour lines, where *0* corresponds to no smoothing.",
+            "dflt": 1,
+            "editType": "plot",
+            "max": 1.3,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_smoothing=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='funnel'))"
-        },
-        "insidetextanchor": {
-          "description": "Determines if texts are kept at center or start/end points in `textposition` *inside* mode.",
-          "dflt": "middle",
-          "editType": "plot",
-          "valType": "enumerated",
-          "values": [
-            "end",
-            "middle",
-            "start"
-          ],
-          "magic_underscores": "fig.update_traces(insidetextanchor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "width": {
+            "description": "Sets the contour line width in (in px)",
+            "dflt": 0.5,
+            "editType": "style+colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='histogram2dcontour'))"
         },
-        "insidetextfont": {
+        "textfont": {
           "color": {
-            "arrayOk": true,
+            "dflt": "auto",
             "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "description": "Sets the font used for `text` lying inside the bar.",
-          "editType": "calc",
+          "description": "For this trace it only has an effect if `coloring` is set to *heatmap*. Sets the text font.",
+          "editType": "plot",
           "family": {
-            "arrayOk": true,
             "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "calc",
+            "editType": "plot",
             "noBlank": true,
             "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "lineposition": {
-            "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "none"
             ],
@@ -48373,61 +40075,38 @@
               "through"
             ],
             "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "role": "object",
           "shadow": {
-            "arrayOk": true,
             "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
             "dflt": "none",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "size": {
-            "arrayOk": true,
-            "editType": "calc",
+            "dflt": "auto",
+            "editType": "plot",
             "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "style": {
-            "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
               "italic"
             ],
-            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "textcase": {
-            "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -48435,18 +40114,12 @@
               "upper",
               "lower"
             ],
-            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "variant": {
-            "arrayOk": true,
             "description": "Sets the variant of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
               "normal",
@@ -48456,18 +40129,12 @@
               "petite-caps",
               "unicase"
             ],
-            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "weight": {
-            "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
             "dflt": "normal",
-            "editType": "calc",
+            "editType": "plot",
             "extras": [
               "normal",
               "bold"
@@ -48475,290 +40142,245 @@
             "max": 1000,
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='funnel'))"
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='histogram2dcontour'))"
         },
-        "outsidetextfont": {
-          "color": {
-            "arrayOk": true,
-            "editType": "style",
+        "colorbar": {
+          "bgcolor": {
+            "description": "Sets the color of padded area.",
+            "dflt": "rgba(0,0,0,0)",
+            "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+          "bordercolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "description": "Sets the font used for `text` lying outside the bar.",
-          "editType": "calc",
-          "family": {
-            "arrayOk": true,
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "borderwidth": {
+            "description": "Sets the width (in px) or the border enclosing this color bar.",
+            "dflt": 0,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+          "dtick": {
+            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "lineposition": {
-            "arrayOk": true,
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "calc",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
+          "editType": "colorbars",
+          "exponentformat": {
+            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+            "dflt": "B",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "none",
+              "e",
+              "E",
+              "power",
+              "SI",
+              "B",
+              "SI extended"
             ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+          "labelalias": {
+            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+            "dflt": false,
+            "editType": "colorbars",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "role": "object",
-          "shadow": {
-            "arrayOk": true,
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "len": {
+            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+          "lenmode": {
+            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+            "dflt": "fraction",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "size": {
-            "arrayOk": true,
-            "editType": "calc",
-            "min": 1,
+          "minexponent": {
+            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+            "dflt": 3,
+            "editType": "colorbars",
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+          "nticks": {
+            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+            "dflt": 0,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "style": {
-            "arrayOk": true,
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "calc",
+          "orientation": {
+            "description": "Sets the orientation of the colorbar.",
+            "dflt": "v",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "italic"
+              "h",
+              "v"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "outlinecolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "outlinewidth": {
+            "description": "Sets the width (in px) of the axis line.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "role": "object",
+          "separatethousands": {
+            "description": "If \"true\", even 4-digit integers are separated",
+            "dflt": false,
+            "editType": "colorbars",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "showexponent": {
+            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
             ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+          "showticklabels": {
+            "description": "Determines whether or not the tick labels are drawn.",
+            "dflt": true,
+            "editType": "colorbars",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "textcase": {
-            "arrayOk": true,
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "calc",
+          "showtickprefix": {
+            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+            "dflt": "all",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
+              "all",
+              "first",
+              "last",
+              "none"
             ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "variant": {
-            "arrayOk": true,
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "calc",
+          "showticksuffix": {
+            "description": "Same as `showtickprefix` but for tick suffixes.",
+            "dflt": "all",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
+              "all",
+              "first",
+              "last",
+              "none"
             ],
-            "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+          "thickness": {
+            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+            "dflt": 30,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "weight": {
-            "arrayOk": true,
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "calc",
-            "extras": [
-              "normal",
-              "bold"
+          "thicknessmode": {
+            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+            "dflt": "pixels",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
             ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+          "tick0": {
+            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='funnel'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='funnel'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "tickangle": {
+            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+            "dflt": "auto",
+            "editType": "colorbars",
+            "valType": "angle",
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          "tickcolor": {
+            "description": "Sets the tick color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='funnel'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='funnel'))"
-      },
-      "categories": [
-        "bar-like",
-        "cartesian",
-        "svg",
-        "oriented",
-        "showLegend",
-        "zoomScale"
-      ],
-      "layoutAttributes": {
-        "funnelgap": {
-          "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates.",
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
-        },
-        "funnelgroupgap": {
-          "description": "Sets the gap (in plot fraction) between bars of the same location coordinate.",
-          "dflt": 0,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number"
-        },
-        "funnelmode": {
-          "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to reduce *opacity* to see multiple bars.",
-          "dflt": "stack",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "stack",
-            "group",
-            "overlay"
-          ]
-        }
-      },
-      "meta": {
-        "description": "Visualize stages in a process using length-encoded bars. This trace can be used to show data in either a part-to-whole representation wherein each item appears in a single stage, or in a \"drop-off\" representation wherein each item appears in each stage it traversed. See also the \"funnelarea\" trace type for a different approach to visualizing funnel data."
-      },
-      "type": "funnel"
-    },
-    "funnelarea": {
-      "animatable": false,
-      "attributes": {
-        "type": "funnelarea",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "title": {
-          "editType": "plot",
-          "font": {
+          "tickfont": {
             "color": {
-              "arrayOk": true,
-              "editType": "plot",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(title_font_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "description": "Sets the font used for `title`.",
-            "editType": "plot",
+            "description": "Sets the color bar's tick label font",
+            "editType": "colorbars",
             "family": {
-              "arrayOk": true,
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "plot",
+              "editType": "colorbars",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(title_font_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "lineposition": {
-              "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "plot",
+              "editType": "colorbars",
               "extras": [
                 "none"
               ],
@@ -48768,896 +40390,741 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "size": {
+              "editType": "colorbars",
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='histogram2dcontour'))"
+          },
+          "tickformat": {
+            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "tickformatstops": {
+            "items": {
+              "tickformatstop": {
+                "dtickrange": {
+                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                  "editType": "colorbars",
+                  "items": [
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    },
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    }
+                  ],
+                  "valType": "info_array"
+                },
+                "editType": "colorbars",
+                "enabled": {
+                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                  "dflt": true,
+                  "editType": "colorbars",
+                  "valType": "boolean"
+                },
+                "name": {
+                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "role": "object",
+                "templateitemname": {
+                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "value": {
+                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                  "dflt": "",
+                  "editType": "colorbars",
+                  "valType": "string"
+                }
+              }
+            },
+            "role": "object",
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='histogram2dcontour'))"
+          },
+          "ticklabeloverflow": {
+            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "allow",
+              "hide past div",
+              "hide past domain"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "ticklabelposition": {
+            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+            "dflt": "outside",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              "outside top",
+              "inside top",
+              "outside left",
+              "inside left",
+              "outside right",
+              "inside right",
+              "outside bottom",
+              "inside bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "ticklabelstep": {
+            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "ticklen": {
+            "description": "Sets the tick length (in px).",
+            "dflt": 5,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "tickmode": {
+            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "valType": "enumerated",
+            "values": [
+              "auto",
+              "linear",
+              "array"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "tickprefix": {
+            "description": "Sets a tick label prefix.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "ticks": {
+            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              ""
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "ticksuffix": {
+            "description": "Sets a tick label suffix.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "ticktext": {
+            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "tickvals": {
+            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "tickwidth": {
+            "description": "Sets the tick width (in px).",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "title": {
+            "editType": "colorbars",
+            "font": {
+              "color": {
+                "editType": "colorbars",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "description": "Sets this color bar's title font.",
+              "editType": "colorbars",
+              "family": {
+                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                "editType": "colorbars",
+                "noBlank": true,
+                "strict": true,
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "lineposition": {
+                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "extras": [
+                  "none"
+                ],
+                "flags": [
+                  "under",
+                  "over",
+                  "through"
+                ],
+                "valType": "flaglist",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "role": "object",
+              "shadow": {
+                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "size": {
+                "editType": "colorbars",
+                "min": 1,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "style": {
+                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "italic"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "textcase": {
+                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+              },
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='histogram2dcontour'))"
             },
             "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(title_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "size": {
-              "arrayOk": true,
-              "editType": "plot",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(title_font_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(title_font_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(title_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "plot",
+            "side": {
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(title_font_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "plot",
-              "extras": [
-                "normal",
-                "bold"
+                "right",
+                "top",
+                "bottom"
               ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(title_font_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+            "text": {
+              "description": "Sets the title of the color bar.",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "magic_underscores": "fig.update_traces(title_font=dict(...), selector=dict(type='funnelarea'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='histogram2dcontour'))"
           },
-          "position": {
-            "description": "Specifies the location of the `title`.",
-            "dflt": "top center",
-            "editType": "plot",
+          "x": {
+            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+            "editType": "colorbars",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "xanchor": {
+            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "top left",
-              "top center",
-              "top right"
+              "left",
+              "center",
+              "right"
             ],
-            "magic_underscores": "fig.update_traces(title_position=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the chart. If it is empty, no title is displayed.",
-            "dflt": "",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(title_text=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "xpad": {
+            "description": "Sets the amount of padding (in px) along the x direction.",
+            "dflt": 10,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(title=dict(...), selector=dict(type='funnelarea'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "size": {
-              "editType": "style",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='funnelarea'))"
+          "xref": {
+            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "container",
+              "paper"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "y": {
+            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+            "editType": "colorbars",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='funnelarea'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "values": {
-          "description": "Sets the values of the sectors. If omitted, we count occurrences of each label.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(values=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "valuessrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "labels": {
-          "description": "Sets the sector labels. If `labels` entries are duplicated, we sum associated `values` or simply count occurrences if `values` is not provided. For other array attributes (including color) we use the first non-empty entry among all occurrences of the label.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(labels=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "labelssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `labels`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "dlabel": {
-          "description": "Sets the label step. See `label0` for more info.",
-          "dflt": 1,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(dlabel=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "yanchor": {
+            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "top",
+              "middle",
+              "bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "ypad": {
+            "description": "Sets the amount of padding (in px) along the y direction.",
+            "dflt": 10,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "yref": {
+            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "container",
+              "paper"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='histogram2dcontour'))"
         },
-        "label0": {
-          "description": "Alternate to `labels`. Builds a numeric set of labels. Use with `dlabel` where `label0` is the starting label and `dlabel` the step.",
-          "dflt": 0,
+        "autocolorscale": {
+          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+          "dflt": true,
           "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(label0=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "text": {
-          "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will be seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "editType": "plot",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "textposition": {
-          "arrayOk": true,
-          "description": "Specifies the location of the `textinfo`.",
-          "dflt": "inside",
-          "editType": "plot",
-          "valType": "enumerated",
-          "values": [
-            "inside",
-            "none"
-          ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "texttemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label`, `color`, `value`, `text` and `percent`.",
-          "dflt": "",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "texttemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
-          "editType": "none",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "label",
-            "text",
-            "value",
-            "percent",
-            "name"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label`, `color`, `value`, `text` and `percent`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        "colorscale": {
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "autocolorscale": false,
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "valType": "colorscale",
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+        "showscale": {
+          "description": "Determines whether or not a colorbar is displayed for this trace.",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+        "reversescale": {
+          "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
+          "dflt": false,
           "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
+        "zauto": {
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
+          "dflt": true,
           "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
+        "zhoverformat": {
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
           "editType": "none",
-          "valType": "string"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "domain": {
-          "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this funnelarea trace .",
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(domain_column=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        "zmax": {
+          "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "zauto": false,
+            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "zmid": {
+          "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
+          "dflt": null,
           "editType": "calc",
-          "role": "object",
-          "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this funnelarea trace .",
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(domain_row=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "x": {
-            "description": "Sets the horizontal domain of this funnelarea trace (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
-            "editType": "calc",
-            "items": [
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_traces(domain_x=list(...), selector=dict(type='funnelarea'))"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "zmin": {
+          "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "zauto": false,
+            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "y": {
-            "description": "Sets the vertical domain of this funnelarea trace (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
-            "editType": "calc",
-            "items": [
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_traces(domain_y=list(...), selector=dict(type='funnelarea'))"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "autocontour": {
+          "description": "Determines whether or not the contour level attributes are picked by an algorithm. If *true*, the number of contour levels can be set in `ncontours`. If *false*, set the contour level attributes in `contours`.",
+          "dflt": true,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(autocontour_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(domain=dict(...), selector=dict(type='funnelarea'))"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autocontour=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "marker": {
-          "colors": {
-            "description": "Sets the color of each sector. If not specified, the default trace color set is used to pick the sector colors.",
+        "contours": {
+          "coloring": {
+            "description": "Determines the coloring method showing the contour values. If *fill*, coloring is done evenly between each contour level If *heatmap*, a heatmap gradient coloring is applied between each contour level. If *lines*, coloring is done on the contour lines. If *none*, no coloring is applied on this trace.",
+            "dflt": "fill",
             "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(marker_colors=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "colorssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `colors`.",
-            "editType": "none",
-            "valType": "string"
+            "valType": "enumerated",
+            "values": [
+              "fill",
+              "heatmap",
+              "lines",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(contours_coloring=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "editType": "calc",
-          "line": {
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the color of the line enclosing each sector. Defaults to the `paper_bgcolor` value.",
-              "dflt": null,
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+          "end": {
+            "description": "Sets the end contour level value. Must be more than `contours.start`",
+            "dflt": null,
+            "editType": "plot",
+            "impliedEdits": {
+              "^autocontour": false,
+              "magic_underscores": "fig.update_traces(contours_end_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "editType": "calc",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(contours_end=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "impliedEdits": {
+            "autocontour": false,
             "role": "object",
-            "width": {
-              "arrayOk": true,
-              "description": "Sets the width (in px) of the line enclosing each sector.",
-              "dflt": 1,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='funnelarea'))"
+            "magic_underscores": "fig.update_traces(contours_impliedEdits=dict(...), selector=dict(type='histogram2dcontour'))"
           },
-          "pattern": {
-            "bgcolor": {
-              "arrayOk": true,
-              "description": "When there is no colorscale sets the color of background pattern fill. Defaults to a `marker.color` background when `fillmode` is *overlay*. Otherwise, defaults to a transparent background.",
+          "labelfont": {
+            "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+              "magic_underscores": "fig.update_traces(contours_labelfont_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
+            "description": "Sets the font used for labeling the contour levels. The default color comes from the lines, if shown. The default family and size come from `layout.font`.",
+            "editType": "plot",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "plot",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(contours_labelfont_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "description": "Sets the pattern within the marker.",
-            "editType": "style",
-            "fgcolor": {
-              "arrayOk": true,
-              "description": "When there is no colorscale sets the color of foreground pattern fill. Defaults to a `marker.color` background when `fillmode` is *replace*. Otherwise, defaults to dark grey or white to increase contrast with the `bgcolor`.",
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "plot",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(contours_labelfont_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "plot",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(contours_labelfont_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "fgopacity": {
-              "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
-              "editType": "style",
-              "max": 1,
-              "min": 0,
+            "size": {
+              "editType": "plot",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_pattern_fgopacity=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+              "magic_underscores": "fig.update_traces(contours_labelfont_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "fillmode": {
-              "description": "Determines whether `marker.color` should be used as a default to `bgcolor` or a `fgcolor`.",
-              "dflt": "replace",
-              "editType": "style",
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
-                "replace",
-                "overlay"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_pattern_fillmode=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "path": {
-              "arrayOk": true,
-              "description": "Sets a custom path for pattern fill. Use with no `shape` or `solidity`, provide an SVG path string for the regions of the square from (0,0) to (`size`,`size`) to color.",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(contours_labelfont_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "role": "object",
-            "shape": {
-              "arrayOk": true,
-              "description": "Sets the shape of the pattern fill. By default, no pattern is used for filling the area.",
-              "dflt": "",
-              "editType": "style",
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
-                "",
-                "/",
-                "\\",
-                "x",
-                "-",
-                "|",
-                "+",
-                "."
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "size": {
-              "arrayOk": true,
-              "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
-              "dflt": 8,
-              "editType": "style",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(contours_labelfont_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "solidity": {
-              "arrayOk": true,
-              "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
-              "dflt": 0.3,
-              "editType": "style",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "plot",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(contours_labelfont_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "plot",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(contours_labelfont_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='funnelarea'))"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='funnelarea'))"
-        },
-        "textfont": {
-          "color": {
-            "arrayOk": true,
-            "editType": "plot",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(contours_labelfont=dict(...), selector=dict(type='histogram2dcontour'))"
           },
-          "description": "Sets the font used for `textinfo`.",
-          "editType": "plot",
-          "family": {
-            "arrayOk": true,
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+          "labelformat": {
+            "description": "Sets the contour label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
+            "dflt": "",
             "editType": "plot",
-            "noBlank": true,
-            "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(contours_labelformat=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "lineposition": {
-            "arrayOk": true,
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "plot",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
+          "operation": {
+            "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed.",
+            "dflt": "=",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "=",
+              "<",
+              ">=",
+              ">",
+              "<=",
+              "[]",
+              "()",
+              "[)",
+              "(]",
+              "][",
+              ")(",
+              "](",
+              ")["
             ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(contours_operation=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "role": "object",
-          "shadow": {
-            "arrayOk": true,
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
+          "showlabels": {
+            "description": "Determines whether to label the contour lines with their values.",
+            "dflt": false,
             "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(contours_showlabels=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+          "showlines": {
+            "description": "Determines whether or not the contour lines are drawn. Has an effect only if `contours.coloring` is set to *fill*.",
+            "dflt": true,
+            "editType": "plot",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(contours_showlines=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "size": {
-            "arrayOk": true,
+            "description": "Sets the step between each contour level. Must be positive.",
+            "dflt": null,
             "editType": "plot",
-            "min": 1,
+            "impliedEdits": {
+              "^autocontour": false,
+              "magic_underscores": "fig.update_traces(contours_size_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "style": {
-            "arrayOk": true,
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "italic"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "textcase": {
-            "arrayOk": true,
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "variant": {
-            "arrayOk": true,
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(contours_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "weight": {
-            "arrayOk": true,
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
+          "start": {
+            "description": "Sets the starting contour level value. Must be less than `contours.end`",
+            "dflt": null,
             "editType": "plot",
-            "extras": [
-              "normal",
-              "bold"
+            "impliedEdits": {
+              "^autocontour": false,
+              "magic_underscores": "fig.update_traces(contours_start_impliedEdits=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(contours_start=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+          },
+          "type": {
+            "description": "If `levels`, the data is represented as a contour plot with multiple levels displayed. If `constraint`, the data is represented as constraints with the invalid region shaded as specified by the `operation` and `value` parameters.",
+            "dflt": "levels",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "levels",
+              "constraint"
             ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            "magic_underscores": "fig.update_traces(contours_type=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+          "value": {
+            "description": "Sets the value or values of the constraint boundary. When `operation` is set to one of the comparison values (`=,<,>=,>,<=`) *value* is expected to be a number. When `operation` is set to one of the interval values (`[],(),[),(],][,)(,](,)[`) *value* is expected to be an array of two numbers where the first is the lower bound and the second is the upper bound.",
+            "dflt": 0,
+            "editType": "calc",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(contours_value=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='funnelarea'))"
-        },
-        "textinfo": {
-          "description": "Determines which trace information appear on the graph.",
-          "editType": "calc",
-          "extras": [
-            "none"
-          ],
-          "flags": [
-            "label",
-            "text",
-            "value",
-            "percent"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(textinfo=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "aspectratio": {
-          "description": "Sets the ratio between height and width",
-          "dflt": 1,
-          "editType": "plot",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(aspectratio=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "baseratio": {
-          "description": "Sets the ratio between bottom length and maximum top length.",
-          "dflt": 0.333,
-          "editType": "plot",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(baseratio=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "magic_underscores": "fig.update_traces(contours=dict(...), selector=dict(type='histogram2dcontour'))"
         },
         "hoverlabel": {
           "align": {
@@ -49671,36 +41138,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "editType": "none",
           "font": {
@@ -49708,12 +41160,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -49724,12 +41171,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -49745,12 +41187,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "role": "object",
             "shadow": {
@@ -49759,24 +41196,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "style": {
               "arrayOk": true,
@@ -49788,12 +41215,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -49807,12 +41229,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "variant": {
               "arrayOk": true,
@@ -49828,12 +41245,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
             "weight": {
               "arrayOk": true,
@@ -49847,14 +41259,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='funnelarea'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='histogram2dcontour'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -49863,12 +41270,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
           "role": "object",
           "showarrow": {
@@ -49876,370 +41278,105 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='funnelarea'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='histogram2dcontour'))"
         },
-        "insidetextfont": {
-          "color": {
-            "arrayOk": true,
-            "editType": "plot",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "description": "Sets the font used for `textinfo` lying inside the sector.",
-          "editType": "plot",
-          "family": {
-            "arrayOk": true,
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "plot",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "lineposition": {
-            "arrayOk": true,
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "plot",
-            "extras": [
-              "none"
-            ],
-            "flags": [
-              "under",
-              "over",
-              "through"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "shadow": {
-            "arrayOk": true,
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "size": {
-            "arrayOk": true,
-            "editType": "plot",
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "style": {
-            "arrayOk": true,
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "italic"
-            ],
-            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "textcase": {
-            "arrayOk": true,
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
-            ],
-            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "variant": {
-            "arrayOk": true,
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
-            ],
-            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "weight": {
-            "arrayOk": true,
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "plot",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='funnelarea'))"
+        "ncontours": {
+          "description": "Sets the maximum number of contour levels. The actual number of contours will be chosen automatically to be less than or equal to the value of `ncontours`. Has an effect only if `autocontour` is *true* or if `contours.size` is missing.",
+          "dflt": 15,
+          "editType": "calc",
+          "min": 1,
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(ncontours=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "scalegroup": {
-          "description": "If there are multiple funnelareas that should be sized according to their totals, link them by providing a non-empty group id here shared by every trace in the same group.",
-          "dflt": "",
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(scalegroup=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
+        },
+        "ycalendar": {
+          "description": "Sets the calendar system to use with `y` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='funnelarea'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='histogram2dcontour'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='funnelarea'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='histogram2dcontour'))"
       },
       "categories": [
-        "pie-like",
-        "funnelarea",
+        "cartesian",
+        "svg",
+        "2dMap",
+        "contour",
+        "histogram",
         "showLegend"
       ],
-      "layoutAttributes": {
-        "extendfunnelareacolors": {
-          "description": "If `true`, the funnelarea slice colors (whether given by `funnelareacolorway` or inherited from `colorway`) will be extended to three times its original length by first repeating every color 20% lighter then each color 20% darker. This is intended to reduce the likelihood of reusing the same color when you have many slices, but you can set `false` to disable. Colors provided in the trace, using `marker.colors`, are never extended.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean"
-        },
-        "funnelareacolorway": {
-          "description": "Sets the default funnelarea slice colors. Defaults to the main `colorway` used for trace colors. If you specify a new list here it can still be extended with lighter and darker colors, see `extendfunnelareacolors`.",
-          "editType": "calc",
-          "valType": "colorlist"
-        },
-        "hiddenlabels": {
-          "description": "hiddenlabels is the funnelarea & pie chart analog of visible:'legendonly' but it can contain many labels, and can simultaneously hide slices from several pies/funnelarea charts",
-          "editType": "calc",
-          "valType": "data_array"
-        },
-        "hiddenlabelssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hiddenlabels`.",
-          "editType": "none",
-          "valType": "string"
-        }
-      },
       "meta": {
-        "description": "Visualize stages in a process using area-encoded trapezoids. This trace can be used to show data in a part-to-whole representation similar to a \"pie\" trace, wherein each item appears in a single stage. See also the \"funnel\" trace type for a different approach to visualizing funnel data."
+        "description": "The sample data from which statistics are computed is set in `x` and `y` (where `x` and `y` represent marginal distributions, binning is set in `xbins` and `ybins` in this case) or `z` (where `z` represent the 2D distribution and binning set, binning is set by `x` and `y` in this case). The resulting distribution is visualized as a contour plot.",
+        "hrName": "histogram_2d_contour"
       },
-      "type": "funnelarea"
+      "type": "histogram2dcontour"
     },
-    "indicator": {
-      "animatable": true,
+    "ohlc": {
+      "animatable": false,
       "attributes": {
-        "type": "indicator",
+        "type": "ohlc",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "uid": {
-          "anim": true,
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-        },
-        "title": {
-          "align": {
-            "description": "Sets the horizontal alignment of the title. It defaults to `center` except for bullet charts for which it defaults to right.",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(title_align=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "editType": "plot",
-          "font": {
-            "color": {
-              "editType": "plot",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(title_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "description": "Set the font used to display the title",
-            "editType": "plot",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "plot",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(title_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "plot",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(title_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "size": {
-              "editType": "plot",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(title_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(title_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(title_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(title_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "plot",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(title_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "magic_underscores": "fig.update_traces(title_font=dict(...), selector=dict(type='indicator'))"
-          },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of this indicator.",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(title_text=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "magic_underscores": "fig.update_traces(title=dict(...), selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -50251,21 +41388,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -50273,7 +41424,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -50283,7 +41434,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -50298,7 +41449,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "role": "object",
             "shadow": {
@@ -50306,13 +41457,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -50323,7 +41474,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -50336,7 +41487,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -50351,7 +41502,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -50364,9 +41515,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='indicator'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='ohlc'))"
           },
           "role": "object",
           "text": {
@@ -50374,361 +41525,352 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='ohlc'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
-        "mode": {
-          "description": "Determines how the value is displayed on the graph. `number` displays the value numerically in text. `delta` displays the difference to a reference value in text. Finally, `gauge` displays the value graphically on an axis.",
-          "dflt": "number",
-          "editType": "calc",
-          "flags": [
-            "number",
-            "delta",
-            "gauge"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "ids": {
-          "anim": true,
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+        "zorder": {
+          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
+          "dflt": 0,
+          "editType": "plot",
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
-        "value": {
-          "anim": true,
-          "description": "Sets the number to be displayed.",
+        "x": {
+          "description": "Sets the x coordinates. If absent, linear coordinate will be generated.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "close": {
+          "description": "Sets the close values.",
           "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(value=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(close=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "open": {
+          "description": "Sets the open values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(open=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "high": {
+          "description": "Sets the high values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(high=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "low": {
+          "description": "Sets the low values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(low=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "text": {
+          "arrayOk": true,
+          "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "hovertext": {
+          "arrayOk": true,
+          "description": "Same as `text`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "hoverinfo": {
+          "arrayOk": true,
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "dflt": "all",
+          "editType": "none",
+          "extras": [
+            "all",
+            "none",
+            "skip"
+          ],
+          "flags": [
+            "x",
+            "y",
+            "z",
+            "text",
+            "name"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `open`, `high`, `low` and `close`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "hovertemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+        "xaxis": {
+          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
+          "dflt": "x",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
-        "domain": {
-          "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this indicator trace .",
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(domain_column=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
+        "yaxis": {
+          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
+          "dflt": "y",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "xperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
           "editType": "calc",
-          "role": "object",
-          "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this indicator trace .",
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(domain_row=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "x": {
-            "description": "Sets the horizontal domain of this indicator trace (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
-            "editType": "calc",
-            "items": [
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_traces(domain_x=list(...), selector=dict(type='indicator'))"
-          },
-          "y": {
-            "description": "Sets the vertical domain of this indicator trace (in plot fraction).",
-            "dflt": [
-              0,
-              1
-            ],
-            "editType": "calc",
-            "items": [
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              },
-              {
-                "editType": "calc",
-                "max": 1,
-                "min": 0,
-                "valType": "number"
-              }
-            ],
-            "valType": "info_array",
-            "magic_underscores": "fig.update_traces(domain_y=list(...), selector=dict(type='indicator'))"
-          },
-          "magic_underscores": "fig.update_traces(domain=dict(...), selector=dict(type='indicator'))"
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
-        "align": {
-          "description": "Sets the horizontal alignment of the `text` within the box. Note that this attribute has no effect if an angular gauge is displayed: in this case, it is always centered",
-          "editType": "plot",
+        "xperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
+          "dflt": "middle",
+          "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "left",
-            "center",
-            "right"
+            "start",
+            "middle",
+            "end"
           ],
-          "magic_underscores": "fig.update_traces(align=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
         },
-        "delta": {
-          "decreasing": {
-            "color": {
-              "description": "Sets the color for increasing value.",
-              "dflt": "#FF4136",
-              "editType": "plot",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(delta_decreasing_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "editType": "plot",
-            "role": "object",
-            "symbol": {
-              "description": "Sets the symbol to display for increasing value",
-              "dflt": "\u25bc",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(delta_decreasing_symbol=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "magic_underscores": "fig.update_traces(delta_decreasing=dict(...), selector=dict(type='indicator'))"
+        "xperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "line": {
+          "dash": {
+            "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*). Note that this style setting can also be set per direction via `increasing.line.dash` and `decreasing.line.dash`.",
+            "dflt": "solid",
+            "editType": "style",
+            "valType": "string",
+            "values": [
+              "solid",
+              "dot",
+              "dash",
+              "longdash",
+              "dashdot",
+              "longdashdot"
+            ],
+            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+          },
+          "editType": "style",
+          "role": "object",
+          "width": {
+            "description": "Sets the line width (in px). Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`.",
+            "dflt": 2,
+            "editType": "style",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='ohlc'))"
+        },
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
           "editType": "calc",
-          "font": {
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "increasing": {
+          "editType": "style",
+          "line": {
             "color": {
-              "editType": "plot",
+              "description": "Sets the line color.",
+              "dflt": "#3D9970",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(delta_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(increasing_line_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
-            "description": "Set the font used to display the delta",
-            "editType": "plot",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "plot",
-              "noBlank": true,
-              "strict": true,
+            "dash": {
+              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+              "dflt": "solid",
+              "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(delta_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "plot",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+              "values": [
+                "solid",
+                "dot",
+                "dash",
+                "longdash",
+                "dashdot",
+                "longdashdot"
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(delta_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(increasing_line_dash=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
+            "editType": "style",
             "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(delta_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "size": {
-              "editType": "plot",
-              "min": 1,
+            "width": {
+              "description": "Sets the line width (in px).",
+              "dflt": 2,
+              "editType": "style",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(delta_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(delta_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(delta_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(delta_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "plot",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(delta_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(increasing_line_width=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
-            "magic_underscores": "fig.update_traces(delta_font=dict(...), selector=dict(type='indicator'))"
+            "magic_underscores": "fig.update_traces(increasing_line=dict(...), selector=dict(type='ohlc'))"
           },
-          "increasing": {
+          "role": "object",
+          "magic_underscores": "fig.update_traces(increasing=dict(...), selector=dict(type='ohlc'))"
+        },
+        "decreasing": {
+          "editType": "style",
+          "line": {
             "color": {
-              "description": "Sets the color for increasing value.",
-              "dflt": "#3D9970",
-              "editType": "plot",
+              "description": "Sets the line color.",
+              "dflt": "#FF4136",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(delta_increasing_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(decreasing_line_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
-            "editType": "plot",
-            "role": "object",
-            "symbol": {
-              "description": "Sets the symbol to display for increasing value",
-              "dflt": "\u25b2",
-              "editType": "plot",
+            "dash": {
+              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+              "dflt": "solid",
+              "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(delta_increasing_symbol=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "values": [
+                "solid",
+                "dot",
+                "dash",
+                "longdash",
+                "dashdot",
+                "longdashdot"
+              ],
+              "magic_underscores": "fig.update_traces(decreasing_line_dash=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
-            "magic_underscores": "fig.update_traces(delta_increasing=dict(...), selector=dict(type='indicator'))"
-          },
-          "position": {
-            "description": "Sets the position of delta with respect to the number.",
-            "dflt": "bottom",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "top",
-              "bottom",
-              "left",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(delta_position=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "prefix": {
-            "description": "Sets a prefix appearing before the delta.",
-            "dflt": "",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(delta_prefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "reference": {
-            "description": "Sets the reference value to compute the delta. By default, it is set to the current value.",
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(delta_reference=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            "editType": "style",
+            "role": "object",
+            "width": {
+              "description": "Sets the line width (in px).",
+              "dflt": 2,
+              "editType": "style",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(decreasing_line_width=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+            },
+            "magic_underscores": "fig.update_traces(decreasing_line=dict(...), selector=dict(type='ohlc'))"
           },
-          "relative": {
-            "description": "Show relative change",
-            "dflt": false,
-            "editType": "plot",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(delta_relative=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "role": "object",
+          "magic_underscores": "fig.update_traces(decreasing=dict(...), selector=dict(type='ohlc'))"
+        },
+        "hoverlabel": {
+          "align": {
+            "arrayOk": true,
+            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
+            "dflt": "auto",
+            "editType": "none",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "right",
+              "auto"
+            ],
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
-          "role": "object",
-          "suffix": {
-            "description": "Sets a suffix appearing next to the delta.",
-            "dflt": "",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(delta_suffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "bgcolor": {
+            "arrayOk": true,
+            "description": "Sets the background color of the hover labels for this trace",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
-          "valueformat": {
-            "description": "Sets the value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(delta_valueformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "bordercolor": {
+            "arrayOk": true,
+            "description": "Sets the border color of the hover labels for this trace.",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
-          "magic_underscores": "fig.update_traces(delta=dict(...), selector=dict(type='indicator'))"
-        },
-        "number": {
-          "editType": "plot",
+          "editType": "none",
           "font": {
             "color": {
-              "editType": "plot",
+              "arrayOk": true,
+              "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(number_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
-            "description": "Set the font used to display main number",
-            "editType": "plot",
+            "description": "Sets the font used in hover labels.",
+            "editType": "none",
             "family": {
+              "arrayOk": true,
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "plot",
+              "editType": "none",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(number_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "lineposition": {
+              "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "plot",
+              "editType": "none",
               "extras": [
                 "none"
               ],
@@ -50738,37 +41880,41 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(number_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "role": "object",
             "shadow": {
+              "arrayOk": true,
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "plot",
+              "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(number_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "size": {
-              "editType": "plot",
+              "arrayOk": true,
+              "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(number_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "style": {
+              "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "plot",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(number_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "textcase": {
+              "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "plot",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -50776,12 +41922,13 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(number_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "variant": {
+              "arrayOk": true,
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "plot",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -50791,12 +41938,13 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(number_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
             "weight": {
+              "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "plot",
+              "editType": "none",
               "extras": [
                 "normal",
                 "bold"
@@ -50804,668 +41952,772 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(number_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
             },
-            "magic_underscores": "fig.update_traces(number_font=dict(...), selector=dict(type='indicator'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='ohlc'))"
           },
-          "prefix": {
-            "description": "Sets a prefix appearing before the number.",
-            "dflt": "",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(number_prefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "namelength": {
+            "arrayOk": true,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
           "role": "object",
-          "suffix": {
-            "description": "Sets a suffix appearing next to the number.",
-            "dflt": "",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(number_suffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
-          "valueformat": {
-            "description": "Sets the value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
-            "dflt": "",
-            "editType": "plot",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(number_valueformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "split": {
+            "description": "Show hover information (open, close, high, low) in separate labels, rather than a single unified label. Default: *false*. When set to *true*, `hovertemplate` is ignored.",
+            "dflt": false,
+            "editType": "style",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_split=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
           },
-          "magic_underscores": "fig.update_traces(number=dict(...), selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='ohlc'))"
         },
-        "gauge": {
-          "axis": {
-            "dtick": {
-              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-              "editType": "plot",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(gauge_axis_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(gauge_axis_dtick=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "editType": "plot",
-            "exponentformat": {
-              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-              "dflt": "B",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "none",
-                "e",
-                "E",
-                "power",
-                "SI",
-                "B",
-                "SI extended"
-              ],
-              "magic_underscores": "fig.update_traces(gauge_axis_exponentformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "labelalias": {
-              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-              "dflt": false,
-              "editType": "plot",
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(gauge_axis_labelalias=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "minexponent": {
-              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-              "dflt": 3,
-              "editType": "plot",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(gauge_axis_minexponent=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "nticks": {
-              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-              "dflt": 0,
-              "editType": "plot",
-              "min": 0,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(gauge_axis_nticks=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "range": {
-              "description": "Sets the range of this axis.",
-              "editType": "plot",
-              "items": [
-                {
-                  "editType": "plot",
-                  "valType": "number"
-                },
-                {
-                  "editType": "plot",
-                  "valType": "number"
-                }
-              ],
-              "valType": "info_array",
-              "magic_underscores": "fig.update_traces(gauge_axis_range=list(...), selector=dict(type='indicator'))"
-            },
-            "role": "object",
-            "separatethousands": {
-              "description": "If \"true\", even 4-digit integers are separated",
-              "dflt": false,
-              "editType": "plot",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(gauge_axis_separatethousands=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "showexponent": {
-              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-              "dflt": "all",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
-                "none"
-              ],
-              "magic_underscores": "fig.update_traces(gauge_axis_showexponent=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "showticklabels": {
-              "description": "Determines whether or not the tick labels are drawn.",
-              "dflt": true,
-              "editType": "plot",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(gauge_axis_showticklabels=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+        "tickwidth": {
+          "description": "Sets the width of the open/close tick marks relative to the *x* minimal interval.",
+          "dflt": 0.3,
+          "editType": "calc",
+          "max": 0.5,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(tickwidth=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='ohlc'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='ohlc'))"
+      },
+      "categories": [
+        "cartesian",
+        "svg",
+        "showLegend"
+      ],
+      "meta": {
+        "description": "The ohlc (short for Open-High-Low-Close) is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The tip of the lines represent the `low` and `high` values and the horizontal segments represent the `open` and `close` values. Sample points where the close value is higher (lower) than the open value are called increasing (decreasing). By default, increasing items are drawn in green whereas decreasing are drawn in red."
+      },
+      "type": "ohlc"
+    },
+    "candlestick": {
+      "animatable": false,
+      "attributes": {
+        "type": "candlestick",
+        "name": {
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "uid": {
+          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            true,
+            false,
+            "legendonly"
+          ],
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "legendgrouptitle": {
+          "editType": "style",
+          "font": {
+            "color": {
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "showtickprefix": {
-              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-              "dflt": "all",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
-                "none"
-              ],
-              "magic_underscores": "fig.update_traces(gauge_axis_showtickprefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            "description": "Sets this legend group's title font.",
+            "editType": "style",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "style",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "showticksuffix": {
-              "description": "Same as `showtickprefix` but for tick suffixes.",
-              "dflt": "all",
-              "editType": "plot",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "style",
+              "extras": [
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(gauge_axis_showticksuffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "tick0": {
-              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-              "editType": "plot",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(gauge_axis_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(gauge_axis_tick0=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "tickangle": {
-              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-              "dflt": "auto",
-              "editType": "plot",
-              "valType": "angle",
-              "magic_underscores": "fig.update_traces(gauge_axis_tickangle=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "tickcolor": {
-              "description": "Sets the tick color.",
-              "dflt": "#444",
-              "editType": "plot",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(gauge_axis_tickcolor=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "tickfont": {
-              "color": {
-                "editType": "plot",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "description": "Sets the color bar's tick label font",
-              "editType": "plot",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "plot",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "plot",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "plot",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "size": {
-                "editType": "plot",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "plot",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "plot",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "plot",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "plot",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "magic_underscores": "fig.update_traces(gauge_axis_tickfont=dict(...), selector=dict(type='indicator'))"
-            },
-            "tickformat": {
-              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-              "dflt": "",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(gauge_axis_tickformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "tickformatstops": {
-              "items": {
-                "tickformatstop": {
-                  "dtickrange": {
-                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                    "editType": "plot",
-                    "items": [
-                      {
-                        "editType": "plot",
-                        "valType": "any"
-                      },
-                      {
-                        "editType": "plot",
-                        "valType": "any"
-                      }
-                    ],
-                    "valType": "info_array"
-                  },
-                  "editType": "plot",
-                  "enabled": {
-                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                    "dflt": true,
-                    "editType": "plot",
-                    "valType": "boolean"
-                  },
-                  "name": {
-                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                    "editType": "plot",
-                    "valType": "string"
-                  },
-                  "role": "object",
-                  "templateitemname": {
-                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                    "editType": "plot",
-                    "valType": "string"
-                  },
-                  "value": {
-                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                    "dflt": "",
-                    "editType": "plot",
-                    "valType": "string"
-                  }
-                }
-              },
-              "role": "object",
-              "magic_underscores": "fig.update_traces(gauge_axis_tickformatstops=list(...), selector=dict(type='indicator'))"
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "ticklabelstep": {
-              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-              "dflt": 1,
-              "editType": "plot",
+            "size": {
+              "editType": "style",
               "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(gauge_axis_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "ticklen": {
-              "description": "Sets the tick length (in px).",
-              "dflt": 5,
-              "editType": "plot",
-              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(gauge_axis_ticklen=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "tickmode": {
-              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-              "editType": "plot",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(gauge_axis_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
-                "auto",
-                "linear",
-                "array"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(gauge_axis_tickmode=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "tickprefix": {
-              "description": "Sets a tick label prefix.",
-              "dflt": "",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(gauge_axis_tickprefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "ticks": {
-              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-              "dflt": "outside",
-              "editType": "plot",
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
-                "outside",
-                "inside",
-                ""
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(gauge_axis_ticks=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "ticksuffix": {
-              "description": "Sets a tick label suffix.",
-              "dflt": "",
-              "editType": "plot",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(gauge_axis_ticksuffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "ticktext": {
-              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-              "editType": "plot",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(gauge_axis_ticktext=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickvals": {
-              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-              "editType": "plot",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(gauge_axis_tickvals=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickwidth": {
-              "description": "Sets the tick width (in px).",
-              "dflt": 1,
-              "editType": "plot",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(gauge_axis_tickwidth=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "visible": {
-              "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false",
-              "dflt": true,
-              "editType": "plot",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(gauge_axis_visible=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-            },
-            "magic_underscores": "fig.update_traces(gauge_axis=dict(...), selector=dict(type='indicator'))"
-          },
-          "bar": {
-            "color": {
-              "description": "Sets the background color of the arc.",
-              "dflt": "green",
-              "editType": "plot",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(gauge_bar_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "description": "Set the appearance of the gauge's value",
-            "editType": "calc",
-            "line": {
-              "color": {
-                "description": "Sets the color of the line enclosing each sector.",
-                "dflt": "#444",
-                "editType": "plot",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(gauge_bar_line_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "editType": "calc",
-              "role": "object",
-              "width": {
-                "description": "Sets the width (in px) of the line enclosing each sector.",
-                "dflt": 0,
-                "editType": "plot",
-                "min": 0,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(gauge_bar_line_width=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "magic_underscores": "fig.update_traces(gauge_bar_line=dict(...), selector=dict(type='indicator'))"
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "role": "object",
-            "thickness": {
-              "description": "Sets the thickness of the bar as a fraction of the total thickness of the gauge.",
-              "dflt": 1,
-              "editType": "plot",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(gauge_bar_thickness=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "magic_underscores": "fig.update_traces(gauge_bar=dict(...), selector=dict(type='indicator'))"
-          },
-          "bgcolor": {
-            "description": "Sets the gauge background color.",
-            "editType": "plot",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(gauge_bgcolor=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "bordercolor": {
-            "description": "Sets the color of the border enclosing the gauge.",
-            "dflt": "#444",
-            "editType": "plot",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(gauge_bordercolor=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='candlestick'))"
           },
-          "borderwidth": {
-            "description": "Sets the width (in px) of the border enclosing the gauge.",
-            "dflt": 1,
-            "editType": "plot",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(gauge_borderwidth=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "role": "object",
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
           },
-          "description": "The gauge of the Indicator plot.",
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='candlestick'))"
+        },
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "zorder": {
+          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
+          "dflt": 0,
+          "editType": "plot",
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "x": {
+          "description": "Sets the x coordinates. If absent, linear coordinate will be generated.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "close": {
+          "description": "Sets the close values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(close=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "open": {
+          "description": "Sets the open values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(open=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "high": {
+          "description": "Sets the high values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(high=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "low": {
+          "description": "Sets the low values.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(low=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "text": {
+          "arrayOk": true,
+          "description": "Sets hover text elements associated with each sample point. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to this trace's sample points.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "hovertext": {
+          "arrayOk": true,
+          "description": "Same as `text`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "hoverinfo": {
+          "arrayOk": true,
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "dflt": "all",
+          "editType": "none",
+          "extras": [
+            "all",
+            "none",
+            "skip"
+          ],
+          "flags": [
+            "x",
+            "y",
+            "z",
+            "text",
+            "name"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `open`, `high`, `low` and `close`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "hovertemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "meta": {
+          "arrayOk": true,
+          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "customdata": {
+          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "xaxis": {
+          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
+          "dflt": "x",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "yaxis": {
+          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
+          "dflt": "y",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "xperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "xperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
+          "dflt": "middle",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "start",
+            "middle",
+            "end"
+          ],
+          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "xperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "line": {
+          "editType": "style",
           "role": "object",
-          "shape": {
-            "description": "Set the shape of the gauge",
-            "dflt": "angular",
-            "editType": "plot",
-            "valType": "enumerated",
-            "values": [
-              "angular",
-              "bullet"
-            ],
-            "magic_underscores": "fig.update_traces(gauge_shape=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          "width": {
+            "description": "Sets the width (in px) of line bounding the box(es). Note that this style setting can also be set per direction via `increasing.line.width` and `decreasing.line.width`.",
+            "dflt": 2,
+            "editType": "style",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
           },
-          "steps": {
-            "items": {
-              "step": {
-                "color": {
-                  "description": "Sets the background color of the arc.",
-                  "editType": "plot",
-                  "valType": "color"
-                },
-                "editType": "calc",
-                "line": {
-                  "color": {
-                    "description": "Sets the color of the line enclosing each sector.",
-                    "dflt": "#444",
-                    "editType": "plot",
-                    "valType": "color"
-                  },
-                  "editType": "calc",
-                  "role": "object",
-                  "width": {
-                    "description": "Sets the width (in px) of the line enclosing each sector.",
-                    "dflt": 0,
-                    "editType": "plot",
-                    "min": 0,
-                    "valType": "number"
-                  }
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "none",
-                  "valType": "string"
-                },
-                "range": {
-                  "description": "Sets the range of this axis.",
-                  "editType": "plot",
-                  "items": [
-                    {
-                      "editType": "plot",
-                      "valType": "number"
-                    },
-                    {
-                      "editType": "plot",
-                      "valType": "number"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "calc",
-                  "valType": "string"
-                },
-                "thickness": {
-                  "description": "Sets the thickness of the bar as a fraction of the total thickness of the gauge.",
-                  "dflt": 1,
-                  "editType": "plot",
-                  "max": 1,
-                  "min": 0,
-                  "valType": "number"
-                }
-              }
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='candlestick'))"
+        },
+        "whiskerwidth": {
+          "description": "Sets the width of the whiskers relative to the box width. For example, with 1, the whiskers are as wide as the box(es).",
+          "dflt": 0,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(whiskerwidth=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+        },
+        "increasing": {
+          "editType": "style",
+          "fillcolor": {
+            "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(increasing_fillcolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "line": {
+            "color": {
+              "description": "Sets the color of line bounding the box(es).",
+              "dflt": "#3D9970",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(increasing_line_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
+            "editType": "style",
             "role": "object",
-            "magic_underscores": "fig.update_traces(gauge_steps=list(...), selector=dict(type='indicator'))"
+            "width": {
+              "description": "Sets the width (in px) of line bounding the box(es).",
+              "dflt": 2,
+              "editType": "style",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(increasing_line_width=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "magic_underscores": "fig.update_traces(increasing_line=dict(...), selector=dict(type='candlestick'))"
           },
-          "threshold": {
-            "editType": "plot",
-            "line": {
-              "color": {
-                "description": "Sets the color of the threshold line.",
-                "dflt": "#444",
-                "editType": "plot",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(gauge_threshold_line_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "editType": "plot",
-              "role": "object",
-              "width": {
-                "description": "Sets the width (in px) of the threshold line.",
-                "dflt": 1,
-                "editType": "plot",
-                "min": 0,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(gauge_threshold_line_width=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-              },
-              "magic_underscores": "fig.update_traces(gauge_threshold_line=dict(...), selector=dict(type='indicator'))"
+          "role": "object",
+          "magic_underscores": "fig.update_traces(increasing=dict(...), selector=dict(type='candlestick'))"
+        },
+        "decreasing": {
+          "editType": "style",
+          "fillcolor": {
+            "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(decreasing_fillcolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "line": {
+            "color": {
+              "description": "Sets the color of line bounding the box(es).",
+              "dflt": "#FF4136",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(decreasing_line_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
+            "editType": "style",
             "role": "object",
-            "thickness": {
-              "description": "Sets the thickness of the threshold line as a fraction of the thickness of the gauge.",
-              "dflt": 0.85,
-              "editType": "plot",
-              "max": 1,
+            "width": {
+              "description": "Sets the width (in px) of line bounding the box(es).",
+              "dflt": 2,
+              "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(gauge_threshold_thickness=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(decreasing_line_width=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "value": {
-              "description": "Sets a treshold value drawn as a line.",
-              "dflt": false,
-              "editType": "calc",
+            "magic_underscores": "fig.update_traces(decreasing_line=dict(...), selector=dict(type='candlestick'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(decreasing=dict(...), selector=dict(type='candlestick'))"
+        },
+        "hoverlabel": {
+          "align": {
+            "arrayOk": true,
+            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
+            "dflt": "auto",
+            "editType": "none",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "right",
+              "auto"
+            ],
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "bgcolor": {
+            "arrayOk": true,
+            "description": "Sets the background color of the hover labels for this trace",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "bordercolor": {
+            "arrayOk": true,
+            "description": "Sets the border color of the hover labels for this trace.",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "editType": "none",
+          "font": {
+            "color": {
+              "arrayOk": true,
+              "editType": "none",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "description": "Sets the font used in hover labels.",
+            "editType": "none",
+            "family": {
+              "arrayOk": true,
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "none",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "lineposition": {
+              "arrayOk": true,
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "none",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "role": "object",
+            "shadow": {
+              "arrayOk": true,
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "none",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "size": {
+              "arrayOk": true,
+              "editType": "none",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(gauge_threshold_value=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
             },
-            "magic_underscores": "fig.update_traces(gauge_threshold=dict(...), selector=dict(type='indicator'))"
+            "style": {
+              "arrayOk": true,
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "textcase": {
+              "arrayOk": true,
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "variant": {
+              "arrayOk": true,
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "none",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "weight": {
+              "arrayOk": true,
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "none",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+            },
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='candlestick'))"
           },
-          "magic_underscores": "fig.update_traces(gauge=dict(...), selector=dict(type='indicator'))"
+          "namelength": {
+            "arrayOk": true,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "role": "object",
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "split": {
+            "description": "Show hover information (open, close, high, low) in separate labels, rather than a single unified label. Default: *false*. When set to *true*, `hovertemplate` is ignored.",
+            "dflt": false,
+            "editType": "style",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_split=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
+          },
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='candlestick'))"
+        },
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='indicator'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='indicator'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='candlestick'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='indicator'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='candlestick'))"
       },
       "categories": [
+        "cartesian",
         "svg",
-        "noOpacity",
-        "noHover"
+        "showLegend",
+        "candlestick",
+        "boxLayout"
       ],
+      "layoutAttributes": {
+        "boxgap": {
+          "description": "Sets the gap (in plot fraction) between boxes of adjacent location coordinates. Has no effect on traces that have *width* set.",
+          "dflt": 0.3,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "boxgroupgap": {
+          "description": "Sets the gap (in plot fraction) between boxes of the same location coordinate. Has no effect on traces that have *width* set.",
+          "dflt": 0.3,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "boxmode": {
+          "description": "Determines how boxes at the same location coordinate are displayed on the graph. If *group*, the boxes are plotted next to one another centered around the shared location. If *overlay*, the boxes are plotted over one another, you might need to set *opacity* to see them multiple boxes. Has no effect on traces that have *width* set.",
+          "dflt": "overlay",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "group",
+            "overlay"
+          ]
+        }
+      },
       "meta": {
-        "description": "An indicator is used to visualize a single `value` along with some contextual information such as `steps` or a `threshold`, using a combination of three visual elements: a number, a delta, and/or a gauge. Deltas are taken with respect to a `reference`. Gauges can be either angular or bullet (aka linear) gauges."
+        "description": "The candlestick is a style of financial chart describing open, high, low and close for a given `x` coordinate (most likely time). The boxes represent the spread between the `open` and `close` values and the lines represent the spread between the `low` and `high` values Sample points where the close value is higher (lower) than the open value are called increasing (decreasing). By default, increasing candles are drawn in green whereas decreasing are drawn in red."
       },
-      "type": "indicator"
+      "type": "candlestick"
     },
-    "scatter3d": {
+    "waterfall": {
       "animatable": false,
       "attributes": {
-        "type": "scatter3d",
+        "type": "waterfall",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -51477,35 +42729,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": true,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -51513,7 +42765,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -51523,7 +42775,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -51538,7 +42790,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "role": "object",
             "shadow": {
@@ -51546,13 +42798,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -51563,7 +42815,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -51576,7 +42828,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -51591,7 +42843,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -51604,9 +42856,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='waterfall'))"
           },
           "role": "object",
           "text": {
@@ -51614,1265 +42866,1579 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='waterfall'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "opacity": {
           "description": "Sets the opacity of the trace.",
           "dflt": 1,
-          "editType": "calc",
+          "editType": "style",
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "mode": {
-          "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points and the trace is not stacked then the default is *lines+markers*. Otherwise, *lines*.",
-          "dflt": "lines+markers",
-          "editType": "calc",
-          "extras": [
-            "none"
-          ],
-          "flags": [
-            "lines",
-            "markers",
-            "text"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+        "zorder": {
+          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
+          "dflt": 0,
+          "editType": "plot",
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "x": {
           "description": "Sets the x coordinates.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
+        "x0": {
+          "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
+          "dflt": 0,
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "dx": {
+          "description": "Sets the x coordinate step. See `x0` for more info.",
+          "dflt": 1,
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(dx=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "y": {
           "description": "Sets the y coordinates.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "z": {
-          "description": "Sets the z coordinates.",
+        "y0": {
+          "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
+          "dflt": 0,
           "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
+        "dy": {
+          "description": "Sets the y coordinate step. See `y0` for more info.",
+          "dflt": 1,
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(dy=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "surfacecolor": {
-          "description": "Sets the surface fill color.",
+        "base": {
+          "arrayOk": false,
+          "description": "Sets where the bar base is drawn (in position axis units).",
+          "dflt": null,
           "editType": "calc",
-          "valType": "color",
-          "magic_underscores": "fig.update_traces(surfacecolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(base=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "width": {
+          "arrayOk": true,
+          "description": "Sets the bar width (in position axis units).",
+          "dflt": null,
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "measure": {
+          "description": "An array containing types of values. By default the values are considered as 'relative'. However; it is possible to use 'total' to compute the sums. Also 'absolute' could be applied to reset the computed total or to declare an initial value where needed.",
+          "dflt": [],
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(measure=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "offset": {
+          "arrayOk": true,
+          "description": "Shifts the position where the bar is drawn (in position axis units). In *group* barmode, traces that set *offset* will be excluded and drawn in *overlay* mode instead.",
+          "dflt": null,
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(offset=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "textposition": {
           "arrayOk": true,
-          "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
-          "dflt": "top center",
+          "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed), unless there is another bar stacked on this one, then the text gets pushed inside. *auto* tries to position `text` inside the bar, but if the bar is too small and no bar is stacked on this one the text is moved outside. If *none*, no text appears.",
+          "dflt": "auto",
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "top left",
-            "top center",
-            "top right",
-            "middle left",
-            "middle center",
-            "middle right",
-            "bottom left",
-            "bottom center",
-            "bottom right"
+            "inside",
+            "outside",
+            "auto",
+            "none"
           ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "texttemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. ",
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `initial`, `delta`, `final` and `label`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "texttemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
-          "editType": "calc",
+          "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "hovertext": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
-          "editType": "calc",
+          "editType": "none",
           "extras": [
             "all",
             "none",
             "skip"
           ],
           "flags": [
+            "name",
             "x",
             "y",
-            "z",
             "text",
-            "name"
+            "initial",
+            "delta",
+            "final"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `initial`, `delta` and `final`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
           "editType": "none",
-          "valType": "string"
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+        "xaxis": {
+          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
+          "dflt": "x",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "scene": {
-          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
-          "dflt": "scene",
+        "yaxis": {
+          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
+          "dflt": "y",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
         },
-        "marker": {
-          "autocolorscale": {
-            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-            "dflt": true,
+        "orientation": {
+          "description": "Sets the orientation of the bars. With *v* (*h*), the value of the each bar spans along the vertical (horizontal).",
+          "editType": "calc+clearAxisTypes",
+          "valType": "enumerated",
+          "values": [
+            "v",
+            "h"
+          ],
+          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "alignmentgroup": {
+          "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "offsetgroup": {
+          "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "xperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "xperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
+          "dflt": "middle",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "start",
+            "middle",
+            "end"
+          ],
+          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "xperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "yperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the y axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(yperiod=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "yperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the y axis.",
+          "dflt": "middle",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "start",
+            "middle",
+            "end"
+          ],
+          "magic_underscores": "fig.update_traces(yperiodalignment=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "yperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the y0 axis. When `y0period` is round number of weeks, the `y0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(yperiod0=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "textangle": {
+          "description": "Sets the angle of the tick labels with respect to the bar. For example, a `tickangle` of -90 draws the tick labels vertically. With *auto* the texts may automatically be rotated to fit with the maximum size in bars.",
+          "dflt": "auto",
+          "editType": "plot",
+          "valType": "angle",
+          "magic_underscores": "fig.update_traces(textangle=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "textfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "description": "Sets the font used for `text`.",
+          "editType": "calc",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
             "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "cauto": {
-            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
-            "dflt": true,
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
             "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "cmax": {
-            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
-            "dflt": null,
+          "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
             "editType": "calc",
-            "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "cmid": {
-            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
-            "dflt": null,
+          "size": {
+            "arrayOk": true,
             "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
+            "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "cmin": {
-            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
-            "dflt": null,
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
             "editType": "calc",
-            "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "color": {
+          "textcase": {
             "arrayOk": true,
-            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
             "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "coloraxis": {
-            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-            "dflt": null,
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
             "editType": "calc",
-            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-            "valType": "subplotid",
-            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
           },
-          "colorbar": {
-            "bgcolor": {
-              "description": "Sets the color of padded area.",
-              "dflt": "rgba(0,0,0,0)",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "bordercolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "borderwidth": {
-              "description": "Sets the width (in px) or the border enclosing this color bar.",
-              "dflt": 0,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "dtick": {
-              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-              "editType": "calc",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
             "editType": "calc",
-            "exponentformat": {
-              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-              "dflt": "B",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "none",
-                "e",
-                "E",
-                "power",
-                "SI",
-                "B",
-                "SI extended"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "labelalias": {
-              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "len": {
-              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "lenmode": {
-              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-              "dflt": "fraction",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "minexponent": {
-              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-              "dflt": 3,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "nticks": {
-              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-              "dflt": 0,
-              "editType": "calc",
-              "min": 0,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "orientation": {
-              "description": "Sets the orientation of the colorbar.",
-              "dflt": "v",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "h",
-                "v"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "outlinecolor": {
-              "description": "Sets the axis line color.",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='waterfall'))"
+        },
+        "textinfo": {
+          "arrayOk": false,
+          "description": "Determines what trace information appears on the graph. In the case of having multiple waterfalls, totals are computed separately (per trace). Flags are rendered in a fixed order; use `texttemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
+          "editType": "plot",
+          "extras": [
+            "none"
+          ],
+          "flags": [
+            "label",
+            "text",
+            "initial",
+            "delta",
+            "final"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(textinfo=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "cliponaxis": {
+          "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.",
+          "dflt": true,
+          "editType": "plot",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(cliponaxis=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "connector": {
+          "editType": "plot",
+          "line": {
+            "color": {
+              "description": "Sets the line color.",
               "dflt": "#444",
-              "editType": "calc",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "outlinewidth": {
-              "description": "Sets the width (in px) of the axis line.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "role": "object",
-            "separatethousands": {
-              "description": "If \"true\", even 4-digit integers are separated",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "showexponent": {
-              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-              "dflt": "all",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
-                "none"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "showticklabels": {
-              "description": "Determines whether or not the tick labels are drawn.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "showtickprefix": {
-              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-              "dflt": "all",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "all",
-                "first",
-                "last",
-                "none"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(connector_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "showticksuffix": {
-              "description": "Same as `showtickprefix` but for tick suffixes.",
-              "dflt": "all",
-              "editType": "calc",
-              "valType": "enumerated",
+            "dash": {
+              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+              "dflt": "solid",
+              "editType": "style",
+              "valType": "string",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "solid",
+                "dot",
+                "dash",
+                "longdash",
+                "dashdot",
+                "longdashdot"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(connector_line_dash=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "thickness": {
-              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-              "dflt": 30,
-              "editType": "calc",
+            "editType": "plot",
+            "role": "object",
+            "width": {
+              "description": "Sets the line width (in px).",
+              "dflt": 2,
+              "editType": "plot",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(connector_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "thicknessmode": {
-              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-              "dflt": "pixels",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(connector_line=dict(...), selector=dict(type='waterfall'))"
+          },
+          "mode": {
+            "description": "Sets the shape of connector lines.",
+            "dflt": "between",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "spanning",
+              "between"
+            ],
+            "magic_underscores": "fig.update_traces(connector_mode=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "role": "object",
+          "visible": {
+            "description": "Determines if connector lines are drawn. ",
+            "dflt": true,
+            "editType": "plot",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(connector_visible=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "magic_underscores": "fig.update_traces(connector=dict(...), selector=dict(type='waterfall'))"
+        },
+        "constraintext": {
+          "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself.",
+          "dflt": "both",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "inside",
+            "outside",
+            "both",
+            "none"
+          ],
+          "magic_underscores": "fig.update_traces(constraintext=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "increasing": {
+          "editType": "style",
+          "marker": {
+            "color": {
+              "arrayOk": false,
+              "description": "Sets the marker color of all increasing values.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(increasing_marker_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "tick0": {
-              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-              "editType": "calc",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "editType": "style",
+            "line": {
+              "color": {
+                "arrayOk": false,
+                "description": "Sets the line color of all increasing values.",
+                "editType": "style",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(increasing_marker_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
               },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "tickangle": {
-              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-              "dflt": "auto",
-              "editType": "calc",
-              "valType": "angle",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "editType": "style",
+              "role": "object",
+              "width": {
+                "arrayOk": false,
+                "description": "Sets the line width of all increasing values.",
+                "dflt": 0,
+                "editType": "style",
+                "min": 0,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(increasing_marker_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+              },
+              "magic_underscores": "fig.update_traces(increasing_marker_line=dict(...), selector=dict(type='waterfall'))"
             },
-            "tickcolor": {
-              "description": "Sets the tick color.",
-              "dflt": "#444",
-              "editType": "calc",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(increasing_marker=dict(...), selector=dict(type='waterfall'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(increasing=dict(...), selector=dict(type='waterfall'))"
+        },
+        "decreasing": {
+          "editType": "style",
+          "marker": {
+            "color": {
+              "arrayOk": false,
+              "description": "Sets the marker color of all decreasing values.",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(decreasing_marker_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "tickfont": {
+            "editType": "style",
+            "line": {
               "color": {
-                "editType": "calc",
+                "arrayOk": false,
+                "description": "Sets the line color of all decreasing values.",
+                "editType": "style",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "description": "Sets the color bar's tick label font",
-              "editType": "calc",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "calc",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "calc",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(decreasing_marker_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
               },
+              "editType": "style",
               "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "calc",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "size": {
-                "editType": "calc",
-                "min": 1,
+              "width": {
+                "arrayOk": false,
+                "description": "Sets the line width of all decreasing values.",
+                "dflt": 0,
+                "editType": "style",
+                "min": 0,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "calc",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(decreasing_marker_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
               },
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(decreasing_marker_line=dict(...), selector=dict(type='waterfall'))"
             },
-            "tickformat": {
-              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "role": "object",
+            "magic_underscores": "fig.update_traces(decreasing_marker=dict(...), selector=dict(type='waterfall'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(decreasing=dict(...), selector=dict(type='waterfall'))"
+        },
+        "hoverlabel": {
+          "align": {
+            "arrayOk": true,
+            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
+            "dflt": "auto",
+            "editType": "none",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "right",
+              "auto"
+            ],
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "bgcolor": {
+            "arrayOk": true,
+            "description": "Sets the background color of the hover labels for this trace",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "bordercolor": {
+            "arrayOk": true,
+            "description": "Sets the border color of the hover labels for this trace.",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "editType": "none",
+          "font": {
+            "color": {
+              "arrayOk": true,
+              "editType": "none",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "tickformatstops": {
-              "items": {
-                "tickformatstop": {
-                  "dtickrange": {
-                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                    "editType": "calc",
-                    "items": [
-                      {
-                        "editType": "calc",
-                        "valType": "any"
-                      },
-                      {
-                        "editType": "calc",
-                        "valType": "any"
-                      }
-                    ],
-                    "valType": "info_array"
-                  },
-                  "editType": "calc",
-                  "enabled": {
-                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                    "dflt": true,
-                    "editType": "calc",
-                    "valType": "boolean"
-                  },
-                  "name": {
-                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                    "editType": "calc",
-                    "valType": "string"
-                  },
-                  "role": "object",
-                  "templateitemname": {
-                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                    "editType": "calc",
-                    "valType": "string"
-                  },
-                  "value": {
-                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                    "dflt": "",
-                    "editType": "calc",
-                    "valType": "string"
-                  }
-                }
-              },
-              "role": "object",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='scatter3d'))"
+            "description": "Sets the font used in hover labels.",
+            "editType": "none",
+            "family": {
+              "arrayOk": true,
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "none",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "ticklabeloverflow": {
-              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "allow",
-                "hide past div",
-                "hide past domain"
+            "lineposition": {
+              "arrayOk": true,
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "none",
+              "extras": [
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "ticklabelposition": {
-              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-              "dflt": "outside",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                "outside top",
-                "inside top",
-                "outside left",
-                "inside left",
-                "outside right",
-                "inside right",
-                "outside bottom",
-                "inside bottom"
+              "flags": [
+                "under",
+                "over",
+                "through"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "ticklabelstep": {
-              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "role": "object",
+            "shadow": {
+              "arrayOk": true,
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "none",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "ticklen": {
-              "description": "Sets the tick length (in px).",
-              "dflt": 5,
-              "editType": "calc",
-              "min": 0,
+            "size": {
+              "arrayOk": true,
+              "editType": "none",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "tickmode": {
-              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
+            "style": {
+              "arrayOk": true,
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
-                "auto",
-                "linear",
-                "array"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "tickprefix": {
-              "description": "Sets a tick label prefix.",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "ticks": {
-              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-              "dflt": "",
-              "editType": "calc",
+            "textcase": {
+              "arrayOk": true,
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
-                "outside",
-                "inside",
-                ""
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "ticksuffix": {
-              "description": "Sets a tick label suffix.",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "ticktext": {
-              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
+            "variant": {
+              "arrayOk": true,
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
               "editType": "none",
-              "valType": "string"
-            },
-            "tickvals": {
-              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
+            "weight": {
+              "arrayOk": true,
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
               "editType": "none",
-              "valType": "string"
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "tickwidth": {
-              "description": "Sets the tick width (in px).",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='waterfall'))"
+          },
+          "namelength": {
+            "arrayOk": true,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "role": "object",
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='waterfall'))"
+        },
+        "insidetextanchor": {
+          "description": "Determines if texts are kept at center or start/end points in `textposition` *inside* mode.",
+          "dflt": "end",
+          "editType": "plot",
+          "valType": "enumerated",
+          "values": [
+            "end",
+            "middle",
+            "start"
+          ],
+          "magic_underscores": "fig.update_traces(insidetextanchor=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "insidetextfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "description": "Sets the font used for `text` lying inside the bar.",
+          "editType": "calc",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+            "editType": "calc",
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "calc",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "size": {
+            "arrayOk": true,
+            "editType": "calc",
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='waterfall'))"
+        },
+        "outsidetextfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "description": "Sets the font used for `text` lying outside the bar.",
+          "editType": "calc",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+            "editType": "calc",
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "calc",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "size": {
+            "arrayOk": true,
+            "editType": "calc",
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+          },
+          "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='waterfall'))"
+        },
+        "totals": {
+          "editType": "style",
+          "marker": {
+            "color": {
+              "arrayOk": false,
+              "description": "Sets the marker color of all intermediate sums and total values.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(totals_marker_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
             },
-            "title": {
-              "editType": "calc",
-              "font": {
-                "color": {
-                  "editType": "calc",
-                  "valType": "color",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "description": "Sets this color bar's title font.",
-                "editType": "calc",
-                "family": {
-                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                  "editType": "calc",
-                  "noBlank": true,
-                  "strict": true,
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "lineposition": {
-                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                  "dflt": "none",
-                  "editType": "calc",
-                  "extras": [
-                    "none"
-                  ],
-                  "flags": [
-                    "under",
-                    "over",
-                    "through"
-                  ],
-                  "valType": "flaglist",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "role": "object",
-                "shadow": {
-                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                  "dflt": "none",
-                  "editType": "calc",
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "size": {
-                  "editType": "calc",
-                  "min": 1,
-                  "valType": "number",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "style": {
-                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "italic"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "textcase": {
-                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "word caps",
-                    "upper",
-                    "lower"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "variant": {
-                  "description": "Sets the variant of the font.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "small-caps",
-                    "all-small-caps",
-                    "all-petite-caps",
-                    "petite-caps",
-                    "unicase"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "weight": {
-                  "description": "Sets the weight (or boldness) of the font.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "extras": [
-                    "normal",
-                    "bold"
-                  ],
-                  "max": 1000,
-                  "min": 1,
-                  "valType": "integer",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-                },
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='scatter3d'))"
+            "editType": "style",
+            "line": {
+              "color": {
+                "arrayOk": false,
+                "description": "Sets the line color of all intermediate sums and total values.",
+                "editType": "style",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(totals_marker_line_color=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
               },
+              "editType": "style",
               "role": "object",
-              "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "right",
-                  "top",
-                  "bottom"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "text": {
-                "description": "Sets the title of the color bar.",
-                "editType": "calc",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "width": {
+                "arrayOk": false,
+                "description": "Sets the line width of all intermediate sums and total values.",
+                "dflt": 0,
+                "editType": "style",
+                "min": 0,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(totals_marker_line_width=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
               },
-              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(totals_marker_line=dict(...), selector=dict(type='waterfall'))"
             },
-            "x": {
-              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "role": "object",
+            "magic_underscores": "fig.update_traces(totals_marker=dict(...), selector=dict(type='waterfall'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(totals=dict(...), selector=dict(type='waterfall'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='waterfall'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='waterfall'))"
+      },
+      "categories": [
+        "bar-like",
+        "cartesian",
+        "svg",
+        "oriented",
+        "showLegend",
+        "zoomScale"
+      ],
+      "layoutAttributes": {
+        "waterfallgap": {
+          "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates.",
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "waterfallgroupgap": {
+          "description": "Sets the gap (in plot fraction) between bars of the same location coordinate.",
+          "dflt": 0,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "waterfallmode": {
+          "description": "Determines how bars at the same location coordinate are displayed on the graph. With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to reduce *opacity* to see multiple bars.",
+          "dflt": "group",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "group",
+            "overlay"
+          ]
+        }
+      },
+      "meta": {
+        "description": "Draws waterfall trace which is useful graph to displays the contribution of various elements (either positive or negative) in a bar chart. The data visualized by the span of the bars is set in `y` if `orientation` is set to *v* (the default) and the labels are set in `x`. By setting `orientation` to *h*, the roles are interchanged."
+      },
+      "type": "waterfall"
+    },
+    "funnel": {
+      "animatable": false,
+      "attributes": {
+        "type": "funnel",
+        "name": {
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "uid": {
+          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            true,
+            false,
+            "legendonly"
+          ],
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "legendgrouptitle": {
+          "editType": "style",
+          "font": {
+            "color": {
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "xanchor": {
-              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "left",
-                "center",
-                "right"
+            "description": "Sets this legend group's title font.",
+            "editType": "style",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "style",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "style",
+              "extras": [
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "xpad": {
-              "description": "Sets the amount of padding (in px) along the x direction.",
-              "dflt": 10,
-              "editType": "calc",
-              "min": 0,
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "size": {
+              "editType": "style",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "xref": {
-              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-              "dflt": "paper",
-              "editType": "calc",
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
-                "container",
-                "paper"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "y": {
-              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "yanchor": {
-              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-              "editType": "calc",
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
-                "top",
-                "middle",
-                "bottom"
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "ypad": {
-              "description": "Sets the amount of padding (in px) along the y direction.",
-              "dflt": 10,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "yref": {
-              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-              "dflt": "paper",
-              "editType": "calc",
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
-                "container",
-                "paper"
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scatter3d'))"
-          },
-          "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "autocolorscale": false,
-              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "valType": "colorscale",
-            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "calc",
-          "line": {
-            "autocolorscale": {
-              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "cauto": {
-              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "cmax": {
-              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "cmid": {
-              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "cmin": {
-              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "coloraxis": {
-              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-              "dflt": null,
-              "editType": "calc",
-              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-              "valType": "subplotid",
-              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "autocolorscale": false,
-                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-              },
-              "valType": "colorscale",
-              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "editType": "calc",
-            "reversescale": {
-              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "role": "object",
-            "width": {
-              "arrayOk": false,
-              "description": "Sets the width (in px) of the lines bounding the marker points.",
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scatter3d'))"
-          },
-          "opacity": {
-            "arrayOk": false,
-            "description": "Sets the marker opacity. Note that the marker opacity for scatter3d traces must be a scalar value for performance reasons. To set a blending opacity value (i.e. which is not transparent), set *marker.color* to an rgba color and use its alpha channel.",
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "reversescale": {
-            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='funnel'))"
           },
           "role": "object",
-          "showscale": {
-            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "size": {
-            "arrayOk": true,
-            "description": "Sets the marker size (in px).",
-            "dflt": 8,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "sizemin": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.",
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizemin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "sizemode": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.",
-            "dflt": "diameter",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "diameter",
-              "area"
-            ],
-            "magic_underscores": "fig.update_traces(marker_sizemode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "sizeref": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.",
-            "dflt": 1,
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "symbol": {
-            "arrayOk": true,
-            "description": "Sets the marker symbol type.",
-            "dflt": "circle",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "circle",
-              "circle-open",
-              "cross",
-              "diamond",
-              "diamond-open",
-              "square",
-              "square-open",
-              "x"
-            ],
-            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='funnel'))"
+        },
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "zorder": {
+          "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
+          "dflt": 0,
+          "editType": "plot",
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(zorder=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "x": {
+          "description": "Sets the x coordinates.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "x0": {
+          "description": "Alternate to `x`. Builds a linear space of x coordinates. Use with `dx` where `x0` is the starting coordinate and `dx` the step.",
+          "dflt": 0,
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(x0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "dx": {
+          "description": "Sets the x coordinate step. See `x0` for more info.",
+          "dflt": 1,
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(dx=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "y": {
+          "description": "Sets the y coordinates.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "y0": {
+          "description": "Alternate to `y`. Builds a linear space of y coordinates. Use with `dy` where `y0` is the starting coordinate and `dy` the step.",
+          "dflt": 0,
+          "editType": "calc+clearAxisTypes",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(y0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "dy": {
+          "description": "Sets the y coordinate step. See `y0` for more info.",
+          "dflt": 1,
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(dy=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "width": {
+          "arrayOk": false,
+          "description": "Sets the bar width (in position axis units).",
+          "dflt": null,
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "offset": {
+          "arrayOk": false,
+          "description": "Shifts the position where the bar is drawn (in position axis units). In *group* barmode, traces that set *offset* will be excluded and drawn in *overlay* mode instead.",
+          "dflt": null,
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(offset=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "text": {
+          "arrayOk": true,
+          "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "textposition": {
+          "arrayOk": true,
+          "description": "Specifies the location of the `text`. *inside* positions `text` inside, next to the bar end (rotated and scaled if needed). *outside* positions `text` outside, next to the bar end (scaled if needed), unless there is another bar stacked on this one, then the text gets pushed inside. *auto* tries to position `text` inside the bar, but if the bar is too small and no bar is stacked on this one the text is moved outside. If *none*, no text appears.",
+          "dflt": "auto",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "inside",
+            "outside",
+            "auto",
+            "none"
+          ],
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "texttemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `percentInitial`, `percentPrevious`, `percentTotal`, `label` and `value`.",
+          "dflt": "",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "texttemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "hovertext": {
+          "arrayOk": true,
+          "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "hoverinfo": {
+          "arrayOk": true,
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "dflt": "all",
+          "editType": "none",
+          "extras": [
+            "all",
+            "none",
+            "skip"
+          ],
+          "flags": [
+            "name",
+            "x",
+            "y",
+            "text",
+            "percent initial",
+            "percent previous",
+            "percent total"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `percentInitial`, `percentPrevious` and `percentTotal`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "hovertemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "meta": {
+          "arrayOk": true,
+          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "customdata": {
+          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "xaxis": {
+          "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
+          "dflt": "x",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(xaxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "yaxis": {
+          "description": "Sets a reference between this trace's y coordinates and a 2D cartesian y axis. If *y* (the default value), the y coordinates refer to `layout.yaxis`. If *y2*, the y coordinates refer to `layout.yaxis2`, and so on.",
+          "dflt": "y",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(yaxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
         },
-        "line": {
+        "orientation": {
+          "description": "Sets the orientation of the funnels. With *v* (*h*), the value of the each bar spans along the vertical (horizontal). By default funnels are tend to be oriented horizontally; unless only *y* array is presented or orientation is set to *v*. Also regarding graphs including only 'horizontal' funnels, *autorange* on the *y-axis* are set to *reversed*.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "enumerated",
+          "values": [
+            "v",
+            "h"
+          ],
+          "magic_underscores": "fig.update_traces(orientation=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "alignmentgroup": {
+          "description": "Set several traces linked to the same position axis or matching axes to the same alignmentgroup. This controls whether bars compute their positional range dependently or independently.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(alignmentgroup=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "offsetgroup": {
+          "description": "Set several traces linked to the same position axis or matching axes to the same offsetgroup where bars of the same position coordinate will line up.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(offsetgroup=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "xperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the x axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "xperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the x axis.",
+          "dflt": "middle",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "start",
+            "middle",
+            "end"
+          ],
+          "magic_underscores": "fig.update_traces(xperiodalignment=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "xperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the x0 axis. When `x0period` is round number of weeks, the `x0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(xperiod0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "yperiod": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the period positioning in milliseconds or *M<n>* on the y axis. Special values in the form of *M<n>* could be used to declare the number of months. In this case `n` must be a positive integer.",
+          "dflt": 0,
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(yperiod=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "yperiodalignment": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the alignment of data points on the y axis.",
+          "dflt": "middle",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "start",
+            "middle",
+            "end"
+          ],
+          "magic_underscores": "fig.update_traces(yperiodalignment=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "yperiod0": {
+          "description": "Only relevant when the axis `type` is *date*. Sets the base for period positioning in milliseconds or date string on the y0 axis. When `y0period` is round number of weeks, the `y0period0` by default would be on a Sunday i.e. 2000-01-02, otherwise it would be at 2000-01-01.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(yperiod0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "marker": {
           "autocolorscale": {
-            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `line.colorscale`. Has an effect only if in `line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
             "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "cauto": {
-            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `line.color`) or the bounds set in `line.cmin` and `line.cmax` Has an effect only if in `line.color` is set to a numerical array. Defaults to `false` when `line.cmin` and `line.cmax` are set by the user.",
+            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
             "dflt": true,
             "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(line_cauto=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "cmax": {
-            "description": "Sets the upper bound of the color domain. Has an effect only if in `line.color` is set to a numerical array. Value should have the same units as in `line.color` and if set, `line.cmin` must be set as well.",
+            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
             "dflt": null,
-            "editType": "calc",
+            "editType": "plot",
             "impliedEdits": {
               "cauto": false,
-              "magic_underscores": "fig.update_traces(line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_cmax=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "cmid": {
-            "description": "Sets the mid-point of the color domain by scaling `line.cmin` and/or `line.cmax` to be equidistant to this point. Has an effect only if in `line.color` is set to a numerical array. Value should have the same units as in `line.color`. Has no effect when `line.cauto` is `false`.",
+            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_cmid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "cmin": {
-            "description": "Sets the lower bound of the color domain. Has an effect only if in `line.color` is set to a numerical array. Value should have the same units as in `line.color` and if set, `line.cmax` must be set as well.",
+            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
             "dflt": null,
-            "editType": "calc",
+            "editType": "plot",
             "impliedEdits": {
               "cauto": false,
-              "magic_underscores": "fig.update_traces(line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_cmin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "color": {
             "arrayOk": true,
-            "description": "Sets the line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `line.cmin` and `line.cmax` if set.",
-            "editType": "calc",
+            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
+            "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "coloraxis": {
             "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -52880,46 +44446,46 @@
             "editType": "calc",
             "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
             "valType": "subplotid",
-            "magic_underscores": "fig.update_traces(line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "colorbar": {
             "bgcolor": {
               "description": "Sets the color of padded area.",
               "dflt": "rgba(0,0,0,0)",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(line_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "bordercolor": {
               "description": "Sets the axis line color.",
               "dflt": "#444",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(line_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "borderwidth": {
               "description": "Sets the width (in px) or the border enclosing this color bar.",
               "dflt": 0,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "dtick": {
               "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-              "editType": "calc",
+              "editType": "colorbars",
               "impliedEdits": {
                 "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(line_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "valType": "any",
-              "magic_underscores": "fig.update_traces(line_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "editType": "calc",
+            "editType": "colorbars",
             "exponentformat": {
               "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
               "dflt": "B",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "none",
@@ -52930,88 +44496,88 @@
                 "B",
                 "SI extended"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "labelalias": {
               "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
               "dflt": false,
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "any",
-              "magic_underscores": "fig.update_traces(line_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "len": {
               "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
               "dflt": 1,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "lenmode": {
               "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
               "dflt": "fraction",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "fraction",
                 "pixels"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "minexponent": {
               "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
               "dflt": 3,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "nticks": {
               "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
               "dflt": 0,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(line_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "orientation": {
               "description": "Sets the orientation of the colorbar.",
               "dflt": "v",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "h",
                 "v"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "outlinecolor": {
               "description": "Sets the axis line color.",
               "dflt": "#444",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(line_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "outlinewidth": {
               "description": "Sets the width (in px) of the axis line.",
               "dflt": 1,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "role": "object",
             "separatethousands": {
               "description": "If \"true\", even 4-digit integers are separated",
               "dflt": false,
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "boolean",
-              "magic_underscores": "fig.update_traces(line_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "showexponent": {
               "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
               "dflt": "all",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "all",
@@ -53019,19 +44585,19 @@
                 "last",
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "showticklabels": {
               "description": "Determines whether or not the tick labels are drawn.",
               "dflt": true,
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "boolean",
-              "magic_underscores": "fig.update_traces(line_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "showtickprefix": {
               "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
               "dflt": "all",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "all",
@@ -53039,12 +44605,12 @@
                 "last",
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "showticksuffix": {
               "description": "Same as `showtickprefix` but for tick suffixes.",
               "dflt": "all",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "all",
@@ -53052,71 +44618,71 @@
                 "last",
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "thickness": {
               "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
               "dflt": 30,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "thicknessmode": {
               "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
               "dflt": "pixels",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "fraction",
                 "pixels"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tick0": {
               "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-              "editType": "calc",
+              "editType": "colorbars",
               "impliedEdits": {
                 "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(line_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "valType": "any",
-              "magic_underscores": "fig.update_traces(line_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickangle": {
               "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
               "dflt": "auto",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "angle",
-              "magic_underscores": "fig.update_traces(line_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickcolor": {
               "description": "Sets the tick color.",
               "dflt": "#444",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(line_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickfont": {
               "color": {
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "description": "Sets the color bar's tick label font",
-              "editType": "calc",
+              "editType": "colorbars",
               "family": {
                 "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "calc",
+                "editType": "colorbars",
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
                 "dflt": "none",
-                "editType": "calc",
+                "editType": "colorbars",
                 "extras": [
                   "none"
                 ],
@@ -53126,37 +44692,37 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "role": "object",
               "shadow": {
                 "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
                 "dflt": "none",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "size": {
-                "editType": "calc",
+                "editType": "colorbars",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -53164,12 +44730,12 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -53179,12 +44745,12 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "extras": [
                   "normal",
                   "bold"
@@ -53192,79 +44758,79 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
-              "magic_underscores": "fig.update_traces(line_colorbar_tickfont=dict(...), selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='funnel'))"
             },
             "tickformat": {
               "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
               "dflt": "",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(line_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickformatstops": {
               "items": {
                 "tickformatstop": {
                   "dtickrange": {
                     "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                    "editType": "calc",
+                    "editType": "colorbars",
                     "items": [
                       {
-                        "editType": "calc",
+                        "editType": "colorbars",
                         "valType": "any"
                       },
                       {
-                        "editType": "calc",
+                        "editType": "colorbars",
                         "valType": "any"
                       }
                     ],
                     "valType": "info_array"
                   },
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "enabled": {
                     "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
                     "dflt": true,
-                    "editType": "calc",
+                    "editType": "colorbars",
                     "valType": "boolean"
                   },
                   "name": {
                     "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                    "editType": "calc",
+                    "editType": "colorbars",
                     "valType": "string"
                   },
                   "role": "object",
                   "templateitemname": {
                     "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                    "editType": "calc",
+                    "editType": "colorbars",
                     "valType": "string"
                   },
                   "value": {
                     "description": "string - dtickformat for described zoom level, the same as *tickformat*",
                     "dflt": "",
-                    "editType": "calc",
+                    "editType": "colorbars",
                     "valType": "string"
                   }
                 }
               },
               "role": "object",
-              "magic_underscores": "fig.update_traces(line_colorbar_tickformatstops=list(...), selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='funnel'))"
             },
             "ticklabeloverflow": {
               "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "allow",
                 "hide past div",
                 "hide past domain"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "ticklabelposition": {
               "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
               "dflt": "outside",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "outside",
@@ -53278,29 +44844,29 @@
                 "outside bottom",
                 "inside bottom"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "ticklabelstep": {
               "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
               "dflt": 1,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(line_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "ticklen": {
               "description": "Sets the tick length (in px).",
               "dflt": 5,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickmode": {
               "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-              "editType": "calc",
+              "editType": "colorbars",
               "impliedEdits": {
-                "magic_underscores": "fig.update_traces(line_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "valType": "enumerated",
               "values": [
@@ -53308,86 +44874,76 @@
                 "linear",
                 "array"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickprefix": {
               "description": "Sets a tick label prefix.",
               "dflt": "",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(line_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "ticks": {
               "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
               "dflt": "",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "outside",
                 "inside",
                 ""
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "ticksuffix": {
               "description": "Sets a tick label suffix.",
               "dflt": "",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(line_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "ticktext": {
               "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "data_array",
-              "magic_underscores": "fig.update_traces(line_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "data_array",
-              "magic_underscores": "fig.update_traces(line_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "title": {
-              "editType": "calc",
+              "editType": "colorbars",
               "font": {
                 "color": {
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "color",
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "description": "Sets this color bar's title font.",
-                "editType": "calc",
+                "editType": "colorbars",
                 "family": {
                   "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "noBlank": true,
                   "strict": true,
                   "valType": "string",
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "lineposition": {
                   "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
                   "dflt": "none",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "extras": [
                     "none"
                   ],
@@ -53397,37 +44953,37 @@
                     "through"
                   ],
                   "valType": "flaglist",
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "role": "object",
                 "shadow": {
                   "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
                   "dflt": "none",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "string",
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "size": {
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "min": 1,
                   "valType": "number",
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "style": {
                   "description": "Sets whether a font should be styled with a normal or italic face from its family.",
                   "dflt": "normal",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "enumerated",
                   "values": [
                     "normal",
                     "italic"
                   ],
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "textcase": {
                   "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
                   "dflt": "normal",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "enumerated",
                   "values": [
                     "normal",
@@ -53435,12 +44991,12 @@
                     "upper",
                     "lower"
                   ],
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "variant": {
                   "description": "Sets the variant of the font.",
                   "dflt": "normal",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "enumerated",
                   "values": [
                     "normal",
@@ -53450,12 +45006,12 @@
                     "petite-caps",
                     "unicase"
                   ],
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
                 "weight": {
                   "description": "Sets the weight (or boldness) of the font.",
                   "dflt": "normal",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "extras": [
                     "normal",
                     "bold"
@@ -53463,174 +45019,257 @@
                   "max": 1000,
                   "min": 1,
                   "valType": "integer",
-                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
                 },
-                "magic_underscores": "fig.update_traces(line_colorbar_title_font=dict(...), selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='funnel'))"
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-                "editType": "calc",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "right",
                   "top",
                   "bottom"
                 ],
-                "magic_underscores": "fig.update_traces(line_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
               "text": {
                 "description": "Sets the title of the color bar.",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(line_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='funnel'))"
               },
-              "magic_underscores": "fig.update_traces(line_colorbar_title=dict(...), selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='funnel'))"
             },
             "x": {
               "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "xanchor": {
               "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "left",
                 "center",
                 "right"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "xpad": {
               "description": "Sets the amount of padding (in px) along the x direction.",
               "dflt": 10,
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "xref": {
               "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
               "dflt": "paper",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "container",
                 "paper"
               ],
-              "magic_underscores": "fig.update_traces(line_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "y": {
+              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+              "editType": "colorbars",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "yanchor": {
+              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "top",
+                "middle",
+                "bottom"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "ypad": {
+              "description": "Sets the amount of padding (in px) along the y direction.",
+              "dflt": 10,
+              "editType": "colorbars",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "yref": {
+              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+              "dflt": "paper",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "container",
+                "paper"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='funnel'))"
+          },
+          "colorscale": {
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "autocolorscale": false,
+              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "valType": "colorscale",
+            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          },
+          "editType": "calc",
+          "line": {
+            "autocolorscale": {
+              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "cauto": {
+              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "cmax": {
+              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
+              "dflt": null,
+              "editType": "plot",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "cmid": {
+              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "cmin": {
+              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
+              "dflt": null,
+              "editType": "plot",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "color": {
+              "arrayOk": true,
+              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "y": {
-              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+            "coloraxis": {
+              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+              "dflt": null,
               "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+              "valType": "subplotid",
+              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "yanchor": {
-              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+            "colorscale": {
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "dflt": null,
               "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "top",
-                "middle",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(line_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "impliedEdits": {
+                "autocolorscale": false,
+                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+              },
+              "valType": "colorscale",
+              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "ypad": {
-              "description": "Sets the amount of padding (in px) along the y direction.",
-              "dflt": 10,
-              "editType": "calc",
+            "editType": "calc",
+            "reversescale": {
+              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
+              "dflt": false,
+              "editType": "plot",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "role": "object",
+            "width": {
+              "arrayOk": true,
+              "description": "Sets the width (in px) of the lines bounding the marker points.",
+              "dflt": 0,
+              "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(line_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "yref": {
-              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-              "dflt": "paper",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
-              ],
-              "magic_underscores": "fig.update_traces(line_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "magic_underscores": "fig.update_traces(line_colorbar=dict(...), selector=dict(type='scatter3d'))"
-          },
-          "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "autocolorscale": false,
-              "magic_underscores": "fig.update_traces(line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "valType": "colorscale",
-            "magic_underscores": "fig.update_traces(line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='funnel'))"
           },
-          "dash": {
-            "description": "Sets the dash style of the lines.",
-            "dflt": "solid",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "dash",
-              "dashdot",
-              "dot",
-              "longdash",
-              "longdashdot",
-              "solid"
-            ],
-            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "opacity": {
+            "arrayOk": true,
+            "description": "Sets the opacity of the bars.",
+            "dflt": 1,
+            "editType": "style",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "editType": "calc",
           "reversescale": {
-            "description": "Reverses the color mapping if true. Has an effect only if in `line.color` is set to a numerical array. If true, `line.cmin` will correspond to the last color in the array and `line.cmax` will correspond to the first color.",
+            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
-            "editType": "calc",
+            "editType": "plot",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(line_reversescale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "role": "object",
           "showscale": {
-            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `line.color` is set to a numerical array.",
+            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
             "dflt": false,
             "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(line_showscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "width": {
-            "description": "Sets the line width (in px).",
-            "dflt": 2,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='funnel'))"
+        },
+        "textangle": {
+          "description": "Sets the angle of the tick labels with respect to the bar. For example, a `tickangle` of -90 draws the tick labels vertically. With *auto* the texts may automatically be rotated to fit with the maximum size in bars.",
+          "dflt": 0,
+          "editType": "plot",
+          "valType": "angle",
+          "magic_underscores": "fig.update_traces(textangle=&lt;VALUE&gt;, selector=dict(type='funnel'))"
         },
         "textfont": {
           "color": {
             "arrayOk": true,
-            "editType": "calc",
+            "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "description": "Sets the text font.",
+          "description": "Sets the font used for `text`.",
           "editType": "calc",
           "family": {
             "arrayOk": true,
@@ -53639,25 +45278,39 @@
             "noBlank": true,
             "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "calc",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
             "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "style": {
             "arrayOk": true,
@@ -53669,12 +45322,21 @@
               "normal",
               "italic"
             ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "variant": {
             "arrayOk": true,
@@ -53684,14 +45346,13 @@
             "valType": "enumerated",
             "values": [
               "normal",
-              "small-caps"
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
             ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "weight": {
             "arrayOk": true,
@@ -53705,344 +45366,106 @@
             "max": 1000,
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='funnel'))"
         },
-        "error_x": {
-          "array": {
-            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_x_array=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "arrayminus": {
-            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_x_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "color": {
-            "description": "Sets the stroke color of the error bars.",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(error_x_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "copy_zstyle": {
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_x_copy_zstyle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "editType": "calc",
-          "role": "object",
-          "symmetric": {
-            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_x_symmetric=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness (in px) of the error bars.",
-            "dflt": 2,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "traceref": {
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_x_traceref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "tracerefminus": {
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_x_tracerefminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "type": {
-            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "percent",
-              "constant",
-              "sqrt",
-              "data"
-            ],
-            "magic_underscores": "fig.update_traces(error_x_type=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "value": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_value=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "valueminus": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_valueminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "visible": {
-            "description": "Determines whether or not this set of error bars is visible.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_x_visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "width": {
-            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_x_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "magic_underscores": "fig.update_traces(error_x=dict(...), selector=dict(type='scatter3d'))"
+        "textinfo": {
+          "arrayOk": false,
+          "description": "Determines what trace information appears on the graph. In the case of having multiple funnels, percentages & totals are computed separately (per trace). Flags are rendered in a fixed order; use `texttemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
+          "editType": "plot",
+          "extras": [
+            "none"
+          ],
+          "flags": [
+            "label",
+            "text",
+            "percent initial",
+            "percent previous",
+            "percent total",
+            "value"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(textinfo=&lt;VALUE&gt;, selector=dict(type='funnel'))"
         },
-        "error_y": {
-          "array": {
-            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_y_array=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "arrayminus": {
-            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_y_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "color": {
-            "description": "Sets the stroke color of the error bars.",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(error_y_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "copy_zstyle": {
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_y_copy_zstyle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
           "editType": "calc",
-          "role": "object",
-          "symmetric": {
-            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_y_symmetric=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness (in px) of the error bars.",
-            "dflt": 2,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "traceref": {
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_y_traceref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "tracerefminus": {
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_y_tracerefminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "type": {
-            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "percent",
-              "constant",
-              "sqrt",
-              "data"
-            ],
-            "magic_underscores": "fig.update_traces(error_y_type=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "value": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_value=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "valueminus": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_valueminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "visible": {
-            "description": "Determines whether or not this set of error bars is visible.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_y_visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "width": {
-            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_y_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "magic_underscores": "fig.update_traces(error_y=dict(...), selector=dict(type='scatter3d'))"
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='funnel'))"
         },
-        "error_z": {
-          "array": {
-            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_z_array=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "arrayminus": {
-            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(error_z_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "arrayminussrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `arrayminus`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "arraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `array`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "color": {
-            "description": "Sets the stroke color of the error bars.",
-            "editType": "calc",
+        "cliponaxis": {
+          "description": "Determines whether the text nodes are clipped about the subplot axes. To show the text nodes above axis lines and tick labels, make sure to set `xaxis.layer` and `yaxis.layer` to *below traces*.",
+          "dflt": true,
+          "editType": "plot",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(cliponaxis=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "connector": {
+          "editType": "plot",
+          "fillcolor": {
+            "description": "Sets the fill color.",
+            "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(error_z_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "editType": "calc",
-          "role": "object",
-          "symmetric": {
-            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_z_symmetric=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness (in px) of the error bars.",
-            "dflt": 2,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_z_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "traceref": {
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_z_traceref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "tracerefminus": {
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(error_z_tracerefminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "type": {
-            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "percent",
-              "constant",
-              "sqrt",
-              "data"
-            ],
-            "magic_underscores": "fig.update_traces(error_z_type=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "value": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_z_value=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(connector_fillcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "valueminus": {
-            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_z_valueminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "line": {
+            "color": {
+              "description": "Sets the line color.",
+              "dflt": "#444",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(connector_line_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "dash": {
+              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+              "dflt": "solid",
+              "editType": "style",
+              "valType": "string",
+              "values": [
+                "solid",
+                "dot",
+                "dash",
+                "longdash",
+                "dashdot",
+                "longdashdot"
+              ],
+              "magic_underscores": "fig.update_traces(connector_line_dash=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "editType": "style",
+            "role": "object",
+            "width": {
+              "description": "Sets the line width (in px).",
+              "dflt": 0,
+              "editType": "plot",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(connector_line_width=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+            },
+            "magic_underscores": "fig.update_traces(connector_line=dict(...), selector=dict(type='funnel'))"
           },
+          "role": "object",
           "visible": {
-            "description": "Determines whether or not this set of error bars is visible.",
-            "editType": "calc",
+            "description": "Determines if connector regions and lines are drawn.",
+            "dflt": true,
+            "editType": "plot",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(error_z_visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "width": {
-            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(error_z_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            "magic_underscores": "fig.update_traces(connector_visible=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "magic_underscores": "fig.update_traces(error_z=dict(...), selector=dict(type='scatter3d'))"
-        },
-        "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "magic_underscores": "fig.update_traces(connector=dict(...), selector=dict(type='funnel'))"
         },
-        "connectgaps": {
-          "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.",
-          "dflt": false,
+        "constraintext": {
+          "description": "Constrain the size of text inside or outside a bar to be no larger than the bar itself.",
+          "dflt": "both",
           "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          "valType": "enumerated",
+          "values": [
+            "inside",
+            "outside",
+            "both",
+            "none"
+          ],
+          "magic_underscores": "fig.update_traces(constraintext=&lt;VALUE&gt;, selector=dict(type='funnel'))"
         },
         "hoverlabel": {
           "align": {
@@ -54056,36 +45479,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "editType": "none",
           "font": {
@@ -54093,12 +45501,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -54109,12 +45512,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -54130,12 +45528,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "role": "object",
             "shadow": {
@@ -54144,24 +45537,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "style": {
               "arrayOk": true,
@@ -54173,12 +45556,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -54192,435 +45570,13 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scatter3d'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='scatter3d'))"
-        },
-        "projection": {
-          "editType": "calc",
-          "role": "object",
-          "x": {
-            "editType": "calc",
-            "opacity": {
-              "description": "Sets the projection color.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(projection_x_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "role": "object",
-            "scale": {
-              "description": "Sets the scale factor determining the size of the projection marker points.",
-              "dflt": 0.6666666666666666,
-              "editType": "calc",
-              "max": 10,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(projection_x_scale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "show": {
-              "description": "Sets whether or not projections are shown along the x axis.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(projection_x_show=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "magic_underscores": "fig.update_traces(projection_x=dict(...), selector=dict(type='scatter3d'))"
-          },
-          "y": {
-            "editType": "calc",
-            "opacity": {
-              "description": "Sets the projection color.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(projection_y_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "role": "object",
-            "scale": {
-              "description": "Sets the scale factor determining the size of the projection marker points.",
-              "dflt": 0.6666666666666666,
-              "editType": "calc",
-              "max": 10,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(projection_y_scale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "show": {
-              "description": "Sets whether or not projections are shown along the y axis.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(projection_y_show=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "magic_underscores": "fig.update_traces(projection_y=dict(...), selector=dict(type='scatter3d'))"
-          },
-          "z": {
-            "editType": "calc",
-            "opacity": {
-              "description": "Sets the projection color.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(projection_z_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "role": "object",
-            "scale": {
-              "description": "Sets the scale factor determining the size of the projection marker points.",
-              "dflt": 0.6666666666666666,
-              "editType": "calc",
-              "max": 10,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(projection_z_scale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "show": {
-              "description": "Sets whether or not projections are shown along the z axis.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(projection_z_show=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-            },
-            "magic_underscores": "fig.update_traces(projection_z=dict(...), selector=dict(type='scatter3d'))"
-          },
-          "magic_underscores": "fig.update_traces(projection=dict(...), selector=dict(type='scatter3d'))"
-        },
-        "surfaceaxis": {
-          "description": "If *-1*, the scatter points are not fill with a surface If *0*, *1*, *2*, the scatter points are filled with a Delaunay surface about the x, y, z respectively.",
-          "dflt": -1,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            -1,
-            0,
-            1,
-            2
-          ],
-          "magic_underscores": "fig.update_traces(surfaceaxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "ycalendar": {
-          "description": "Sets the calendar system to use with `y` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "zcalendar": {
-          "description": "Sets the calendar system to use with `z` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(zcalendar=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scatter3d'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='scatter3d'))"
-      },
-      "categories": [
-        "gl3d",
-        "symbols",
-        "showLegend",
-        "scatter-like"
-      ],
-      "meta": {
-        "description": "The data visualized as scatter point or lines in 3D dimension is set in `x`, `y`, `z`. Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` Projections are achieved via `projection`. Surface fills are achieved via `surfaceaxis`.",
-        "hrName": "scatter_3d"
-      },
-      "type": "scatter3d"
-    },
-    "surface": {
-      "animatable": false,
-      "attributes": {
-        "type": "surface",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": false,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "size": {
-              "editType": "style",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "italic"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
-              "valType": "enumerated",
-              "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "variant": {
+              "arrayOk": true,
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "style",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -54630,12 +45586,13 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
             "weight": {
+              "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "style",
+              "editType": "none",
               "extras": [
                 "normal",
                 "bold"
@@ -54643,449 +45600,347 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='funnel'))"
+          },
+          "namelength": {
+            "arrayOk": true,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
           "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='surface'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
-          "dflt": 1,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x": {
-          "description": "Sets the x coordinates.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y": {
-          "description": "Sets the y coordinates.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "z": {
-          "description": "Sets the z coordinates.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "surfacecolor": {
-          "description": "Sets the surface color values, used for setting a color scale independent of `z`.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(surfacecolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "surfacecolorsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `surfacecolor`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "text": {
-          "arrayOk": true,
-          "description": "Sets the text elements associated with each z value. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Same as `text`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
-          "editType": "calc",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "x",
-            "y",
-            "z",
-            "text",
-            "name"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='funnel'))"
         },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+        "insidetextanchor": {
+          "description": "Determines if texts are kept at center or start/end points in `textposition` *inside* mode.",
+          "dflt": "middle",
           "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "scene": {
-          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
-          "dflt": "scene",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "coloraxis": {
-          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-          "dflt": null,
-          "editType": "calc",
-          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "valType": "enumerated",
+          "values": [
+            "end",
+            "middle",
+            "start"
+          ],
+          "magic_underscores": "fig.update_traces(insidetextanchor=&lt;VALUE&gt;, selector=dict(type='funnel'))"
         },
-        "colorbar": {
-          "bgcolor": {
-            "description": "Sets the color of padded area.",
-            "dflt": "rgba(0,0,0,0)",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "bordercolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "calc",
+        "insidetextfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "style",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "borderwidth": {
-            "description": "Sets the width (in px) or the border enclosing this color bar.",
-            "dflt": 0,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "dtick": {
-            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+          "description": "Sets the font used for `text` lying inside the bar.",
+          "editType": "calc",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
             "editType": "calc",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "editType": "calc",
-          "exponentformat": {
-            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-            "dflt": "B",
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
             "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "none",
-              "e",
-              "E",
-              "power",
-              "SI",
-              "B",
-              "SI extended"
+            "extras": [
+              "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "labelalias": {
-            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-            "dflt": false,
+          "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
             "editType": "calc",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "len": {
-            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-            "dflt": 1,
+          "size": {
+            "arrayOk": true,
             "editType": "calc",
-            "min": 0,
+            "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "lenmode": {
-            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-            "dflt": "fraction",
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
             "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "fraction",
-              "pixels"
+              "normal",
+              "italic"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "minexponent": {
-            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-            "dflt": 3,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "nticks": {
-            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-            "dflt": 0,
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
             "editType": "calc",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "orientation": {
-            "description": "Sets the orientation of the colorbar.",
-            "dflt": "v",
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
             "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "h",
-              "v"
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "outlinecolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
             "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "outlinewidth": {
-            "description": "Sets the width (in px) of the axis line.",
-            "dflt": 1,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='funnel'))"
+        },
+        "outsidetextfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "style",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "role": "object",
-          "separatethousands": {
-            "description": "If \"true\", even 4-digit integers are separated",
-            "dflt": false,
+          "description": "Sets the font used for `text` lying outside the bar.",
+          "editType": "calc",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
             "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "showexponent": {
-            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-            "dflt": "all",
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
             "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
+            "extras": [
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "showticklabels": {
-            "description": "Determines whether or not the tick labels are drawn.",
-            "dflt": true,
+          "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
             "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "showtickprefix": {
-            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-            "dflt": "all",
+          "size": {
+            "arrayOk": true,
             "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "showticksuffix": {
-            "description": "Same as `showtickprefix` but for tick suffixes.",
-            "dflt": "all",
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
             "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "all",
-              "first",
-              "last",
-              "none"
+              "normal",
+              "italic"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-            "dflt": 30,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "thicknessmode": {
-            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-            "dflt": "pixels",
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
             "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "fraction",
-              "pixels"
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "tick0": {
-            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "calc",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "tickangle": {
-            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-            "dflt": "auto",
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
             "editType": "calc",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "tickcolor": {
-            "description": "Sets the tick color.",
-            "dflt": "#444",
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
             "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='funnel'))"
           },
-          "tickfont": {
+          "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='funnel'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='funnel'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='funnel'))"
+      },
+      "categories": [
+        "bar-like",
+        "cartesian",
+        "svg",
+        "oriented",
+        "showLegend",
+        "zoomScale"
+      ],
+      "layoutAttributes": {
+        "funnelgap": {
+          "description": "Sets the gap (in plot fraction) between bars of adjacent location coordinates.",
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "funnelgroupgap": {
+          "description": "Sets the gap (in plot fraction) between bars of the same location coordinate.",
+          "dflt": 0,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number"
+        },
+        "funnelmode": {
+          "description": "Determines how bars at the same location coordinate are displayed on the graph. With *stack*, the bars are stacked on top of one another With *group*, the bars are plotted next to one another centered around the shared location. With *overlay*, the bars are plotted over one another, you might need to reduce *opacity* to see multiple bars.",
+          "dflt": "stack",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "stack",
+            "group",
+            "overlay"
+          ]
+        }
+      },
+      "meta": {
+        "description": "Visualize stages in a process using length-encoded bars. This trace can be used to show data in either a part-to-whole representation wherein each item appears in a single stage, or in a \"drop-off\" representation wherein each item appears in each stage it traversed. See also the \"funnelarea\" trace type for a different approach to visualizing funnel data."
+      },
+      "type": "funnel"
+    },
+    "funnelarea": {
+      "animatable": false,
+      "attributes": {
+        "type": "funnelarea",
+        "name": {
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "uid": {
+          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "title": {
+          "editType": "plot",
+          "font": {
             "color": {
-              "editType": "calc",
+              "arrayOk": true,
+              "editType": "plot",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "description": "Sets the color bar's tick label font",
-            "editType": "calc",
+            "description": "Sets the font used for `title`.",
+            "editType": "plot",
             "family": {
+              "arrayOk": true,
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "calc",
+              "editType": "plot",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "lineposition": {
+              "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "calc",
+              "editType": "plot",
               "extras": [
                 "none"
               ],
@@ -55095,37 +45950,41 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "role": "object",
             "shadow": {
+              "arrayOk": true,
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "calc",
+              "editType": "plot",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "size": {
-              "editType": "calc",
+              "arrayOk": true,
+              "editType": "plot",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "style": {
+              "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "textcase": {
+              "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -55133,12 +45992,13 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "variant": {
+              "arrayOk": true,
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -55148,12 +46008,13 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "weight": {
+              "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "plot",
               "extras": [
                 "normal",
                 "bold"
@@ -55161,795 +46022,644 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='surface'))"
-          },
-          "tickformat": {
-            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-            "dflt": "",
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "tickformatstops": {
-            "items": {
-              "tickformatstop": {
-                "dtickrange": {
-                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "calc",
-                  "items": [
-                    {
-                      "editType": "calc",
-                      "valType": "any"
-                    },
-                    {
-                      "editType": "calc",
-                      "valType": "any"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "editType": "calc",
-                "enabled": {
-                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                  "dflt": true,
-                  "editType": "calc",
-                  "valType": "boolean"
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "calc",
-                  "valType": "string"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "calc",
-                  "valType": "string"
-                },
-                "value": {
-                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                  "dflt": "",
-                  "editType": "calc",
-                  "valType": "string"
-                }
-              }
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='surface'))"
-          },
-          "ticklabeloverflow": {
-            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "allow",
-              "hide past div",
-              "hide past domain"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "ticklabelposition": {
-            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-            "dflt": "outside",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              "outside top",
-              "inside top",
-              "outside left",
-              "inside left",
-              "outside right",
-              "inside right",
-              "outside bottom",
-              "inside bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "ticklabelstep": {
-            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-            "dflt": 1,
-            "editType": "calc",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "ticklen": {
-            "description": "Sets the tick length (in px).",
-            "dflt": 5,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "tickmode": {
-            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(title_font_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "valType": "enumerated",
-            "values": [
-              "auto",
-              "linear",
-              "array"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "tickprefix": {
-            "description": "Sets a tick label prefix.",
-            "dflt": "",
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(title_font=dict(...), selector=dict(type='funnelarea'))"
           },
-          "ticks": {
-            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-            "dflt": "",
-            "editType": "calc",
+          "position": {
+            "description": "Specifies the location of the `title`.",
+            "dflt": "top center",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
-              "outside",
-              "inside",
-              ""
+              "top left",
+              "top center",
+              "top right"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(title_position=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "ticksuffix": {
-            "description": "Sets a tick label suffix.",
+          "role": "object",
+          "text": {
+            "description": "Sets the title of the chart. If it is empty, no title is displayed.",
             "dflt": "",
-            "editType": "calc",
+            "editType": "plot",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "ticktext": {
-            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickvals": {
-            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickwidth": {
-            "description": "Sets the tick width (in px).",
-            "dflt": 1,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(title_text=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "title": {
-            "editType": "calc",
-            "font": {
-              "color": {
-                "editType": "calc",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "description": "Sets this color bar's title font.",
-              "editType": "calc",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "calc",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "calc",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "calc",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "size": {
-                "editType": "calc",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "calc",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(title=dict(...), selector=dict(type='funnelarea'))"
+        },
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            true,
+            false,
+            "legendonly"
+          ],
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "legendgrouptitle": {
+          "editType": "style",
+          "font": {
+            "color": {
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            },
+            "description": "Sets this legend group's title font.",
+            "editType": "style",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "style",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            },
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "style",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            },
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            },
+            "size": {
+              "editType": "style",
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            },
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "role": "object",
-            "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "calc",
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
-                "right",
-                "top",
-                "bottom"
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "text": {
-              "description": "Sets the title of the color bar.",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='surface'))"
-          },
-          "x": {
-            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "xanchor": {
-            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "xpad": {
-            "description": "Sets the amount of padding (in px) along the x direction.",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "xref": {
-            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-            "dflt": "paper",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "y": {
-            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "yanchor": {
-            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "top",
-              "middle",
-              "bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "ypad": {
-            "description": "Sets the amount of padding (in px) along the y direction.",
-            "dflt": 10,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "yref": {
-            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-            "dflt": "paper",
-            "editType": "calc",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            },
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='funnelarea'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='surface'))"
-        },
-        "autocolorscale": {
-          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": false,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "role": "object",
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='funnelarea'))"
         },
-        "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "showscale": {
-          "description": "Determines whether or not a colorbar is displayed for this trace.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
-          "dflt": false,
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
-          "dflt": "",
+        "values": {
+          "description": "Sets the values of the sectors. If omitted, we count occurrences of each label.",
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(values=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "cauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here z or surfacecolor) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
-          "dflt": true,
+        "labels": {
+          "description": "Sets the sector labels. If `labels` entries are duplicated, we sum associated `values` or simply count occurrences if `values` is not provided. For other array attributes (including color) we use the first non-empty entry among all occurrences of the label.",
           "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(labels=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "cmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as z or surfacecolor and if set, `cmin` must be set as well.",
-          "dflt": null,
+        "dlabel": {
+          "description": "Sets the label step. See `label0` for more info.",
+          "dflt": 1,
           "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(dlabel=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "cmid": {
-          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as z or surfacecolor. Has no effect when `cauto` is `false`.",
-          "dflt": null,
+        "label0": {
+          "description": "Alternate to `labels`. Builds a numeric set of labels. Use with `dlabel` where `label0` is the starting label and `dlabel` the step.",
+          "dflt": 0,
           "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(label0=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "cmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as z or surfacecolor and if set, `cmax` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        "text": {
+          "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will be seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "editType": "plot",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "connectgaps": {
-          "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the `z` data are filled in.",
-          "dflt": false,
+        "textposition": {
+          "arrayOk": true,
+          "description": "Specifies the location of the `textinfo`.",
+          "dflt": "inside",
+          "editType": "plot",
+          "valType": "enumerated",
+          "values": [
+            "inside",
+            "none"
+          ],
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "texttemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label`, `color`, `value`, `text` and `percent`.",
+          "dflt": "",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "texttemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "hovertext": {
+          "arrayOk": true,
+          "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "hoverinfo": {
+          "arrayOk": true,
+          "description": "Determines what trace information appears on hover. Flags are rendered in a fixed order; use `hovertemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
+          "dflt": "all",
+          "editType": "none",
+          "extras": [
+            "all",
+            "none",
+            "skip"
+          ],
+          "flags": [
+            "label",
+            "text",
+            "value",
+            "percent",
+            "name"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `label`, `color`, `value`, `text` and `percent`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "hovertemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "meta": {
+          "arrayOk": true,
+          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "customdata": {
+          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "contours": {
+        "domain": {
+          "column": {
+            "description": "If there is a layout grid, use the domain for this column in the grid for this funnelarea trace.",
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(domain_column=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
           "editType": "calc",
           "role": "object",
-          "x": {
-            "color": {
-              "description": "Sets the color of the contour lines.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(contours_x_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
+          "row": {
+            "description": "If there is a layout grid, use the domain for this row in the grid for this funnelarea trace.",
+            "dflt": 0,
             "editType": "calc",
-            "end": {
-              "description": "Sets the end contour level value. Must be more than `contours.start`",
-              "dflt": null,
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_x_end=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "highlight": {
-              "description": "Determines whether or not contour lines about the x dimension are highlighted on hover.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_x_highlight=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "highlightcolor": {
-              "description": "Sets the color of the highlighted contour lines.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(contours_x_highlightcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "highlightwidth": {
-              "description": "Sets the width of the highlighted contour lines.",
-              "dflt": 2,
-              "editType": "calc",
-              "max": 16,
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_x_highlightwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "project": {
-              "editType": "calc",
-              "role": "object",
-              "x": {
-                "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
-                "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_x_project_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "y": {
-                "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
-                "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_x_project_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "z": {
-                "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
-                "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_x_project_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "magic_underscores": "fig.update_traces(contours_x_project=dict(...), selector=dict(type='surface'))"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not contour lines about the x dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_x_show=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "size": {
-              "description": "Sets the step between each contour level. Must be positive.",
-              "dflt": null,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_x_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "start": {
-              "description": "Sets the starting contour level value. Must be less than `contours.end`",
-              "dflt": null,
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_x_start=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "usecolormap": {
-              "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_x_usecolormap=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "width": {
-              "description": "Sets the width of the contour lines.",
-              "dflt": 2,
-              "editType": "calc",
-              "max": 16,
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_x_width=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "magic_underscores": "fig.update_traces(contours_x=dict(...), selector=dict(type='surface'))"
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(domain_row=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "y": {
-            "color": {
-              "description": "Sets the color of the contour lines.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(contours_y_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
+          "x": {
+            "description": "Sets the horizontal domain of this funnelarea trace (in plot fraction).",
+            "dflt": [
+              0,
+              1
+            ],
             "editType": "calc",
-            "end": {
-              "description": "Sets the end contour level value. Must be more than `contours.start`",
-              "dflt": null,
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_y_end=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "highlight": {
-              "description": "Determines whether or not contour lines about the y dimension are highlighted on hover.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_y_highlight=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "highlightcolor": {
-              "description": "Sets the color of the highlighted contour lines.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(contours_y_highlightcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "highlightwidth": {
-              "description": "Sets the width of the highlighted contour lines.",
-              "dflt": 2,
-              "editType": "calc",
-              "max": 16,
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_y_highlightwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "project": {
-              "editType": "calc",
-              "role": "object",
-              "x": {
-                "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
+            "items": [
+              {
                 "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_y_project_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
+                "max": 1,
+                "min": 0,
+                "valType": "number"
               },
-              "y": {
-                "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              }
+            ],
+            "valType": "info_array",
+            "magic_underscores": "fig.update_traces(domain_x=list(...), selector=dict(type='funnelarea'))"
+          },
+          "y": {
+            "description": "Sets the vertical domain of this funnelarea trace (in plot fraction).",
+            "dflt": [
+              0,
+              1
+            ],
+            "editType": "calc",
+            "items": [
+              {
                 "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_y_project_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
+                "max": 1,
+                "min": 0,
+                "valType": "number"
               },
-              "z": {
-                "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
+              {
                 "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_y_project_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "magic_underscores": "fig.update_traces(contours_y_project=dict(...), selector=dict(type='surface'))"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not contour lines about the y dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_y_show=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "size": {
-              "description": "Sets the step between each contour level. Must be positive.",
-              "dflt": null,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_y_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "start": {
-              "description": "Sets the starting contour level value. Must be less than `contours.end`",
-              "dflt": null,
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_y_start=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "usecolormap": {
-              "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_y_usecolormap=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "width": {
-              "description": "Sets the width of the contour lines.",
-              "dflt": 2,
-              "editType": "calc",
-              "max": 16,
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_y_width=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "magic_underscores": "fig.update_traces(contours_y=dict(...), selector=dict(type='surface'))"
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              }
+            ],
+            "valType": "info_array",
+            "magic_underscores": "fig.update_traces(domain_y=list(...), selector=dict(type='funnelarea'))"
           },
-          "z": {
+          "magic_underscores": "fig.update_traces(domain=dict(...), selector=dict(type='funnelarea'))"
+        },
+        "marker": {
+          "colors": {
+            "description": "Sets the color of each sector. If not specified, the default trace color set is used to pick the sector colors.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(marker_colors=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "editType": "calc",
+          "line": {
             "color": {
-              "description": "Sets the color of the contour lines.",
-              "dflt": "#444",
-              "editType": "calc",
+              "arrayOk": true,
+              "description": "Sets the color of the line enclosing each sector. Defaults to the `paper_bgcolor` value.",
+              "dflt": null,
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(contours_z_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "editType": "calc",
-            "end": {
-              "description": "Sets the end contour level value. Must be more than `contours.start`",
-              "dflt": null,
-              "editType": "calc",
+            "role": "object",
+            "width": {
+              "arrayOk": true,
+              "description": "Sets the width (in px) of the line enclosing each sector.",
+              "dflt": 1,
+              "editType": "style",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_z_end=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "highlight": {
-              "description": "Determines whether or not contour lines about the z dimension are highlighted on hover.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_z_highlight=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='funnelarea'))"
+          },
+          "pattern": {
+            "bgcolor": {
+              "arrayOk": true,
+              "description": "When there is no colorscale sets the color of background pattern fill. Defaults to a `marker.color` background when `fillmode` is *overlay*. Otherwise, defaults to a transparent background.",
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "highlightcolor": {
-              "description": "Sets the color of the highlighted contour lines.",
-              "dflt": "#444",
-              "editType": "calc",
+            "description": "Sets the pattern within the marker.",
+            "editType": "style",
+            "fgcolor": {
+              "arrayOk": true,
+              "description": "When there is no colorscale sets the color of foreground pattern fill. Defaults to a `marker.color` background when `fillmode` is *replace*. Otherwise, defaults to dark grey or white to increase contrast with the `bgcolor`.",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(contours_z_highlightcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "highlightwidth": {
-              "description": "Sets the width of the highlighted contour lines.",
-              "dflt": 2,
-              "editType": "calc",
-              "max": 16,
-              "min": 1,
+            "fgopacity": {
+              "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
+              "editType": "style",
+              "max": 1,
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_z_highlightwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(marker_pattern_fgopacity=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "project": {
-              "editType": "calc",
-              "role": "object",
-              "x": {
-                "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
-                "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_z_project_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "y": {
-                "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
-                "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_z_project_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "z": {
-                "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
-                "dflt": false,
-                "editType": "calc",
-                "valType": "boolean",
-                "magic_underscores": "fig.update_traces(contours_z_project_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
-              },
-              "magic_underscores": "fig.update_traces(contours_z_project=dict(...), selector=dict(type='surface'))"
+            "fillmode": {
+              "description": "Determines whether `marker.color` should be used as a default to `bgcolor` or a `fgcolor`.",
+              "dflt": "replace",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "replace",
+                "overlay"
+              ],
+              "magic_underscores": "fig.update_traces(marker_pattern_fillmode=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+            },
+            "path": {
+              "arrayOk": true,
+              "description": "Sets a custom path for pattern fill. Use with no `shape` or `solidity`, provide an SVG path string for the regions of the square from (0,0) to (`size`,`size`) to color.",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "role": "object",
-            "show": {
-              "description": "Determines whether or not contour lines about the z dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_z_show=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "shape": {
+              "arrayOk": true,
+              "description": "Sets the shape of the pattern fill. By default, no pattern is used for filling the area.",
+              "dflt": "",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "",
+                "/",
+                "\\",
+                "x",
+                "-",
+                "|",
+                "+",
+                "."
+              ],
+              "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "size": {
-              "description": "Sets the step between each contour level. Must be positive.",
-              "dflt": null,
-              "editType": "calc",
+              "arrayOk": true,
+              "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
+              "dflt": 8,
+              "editType": "style",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_z_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "start": {
-              "description": "Sets the starting contour level value. Must be less than `contours.end`",
-              "dflt": null,
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_z_start=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "usecolormap": {
-              "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(contours_z_usecolormap=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "width": {
-              "description": "Sets the width of the contour lines.",
-              "dflt": 2,
-              "editType": "calc",
-              "max": 16,
-              "min": 1,
+            "solidity": {
+              "arrayOk": true,
+              "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
+              "dflt": 0.3,
+              "editType": "style",
+              "max": 1,
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(contours_z_width=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "magic_underscores": "fig.update_traces(contours_z=dict(...), selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='funnelarea'))"
           },
-          "magic_underscores": "fig.update_traces(contours=dict(...), selector=dict(type='surface'))"
+          "role": "object",
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='funnelarea'))"
         },
-        "hidesurface": {
-          "description": "Determines whether or not a surface is drawn. For example, set `hidesurface` to *false* `contours.x.show` to *true* and `contours.y.show` to *true* to draw a wire frame plot.",
-          "dflt": false,
+        "textfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "plot",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "description": "Sets the font used for `textinfo`.",
+          "editType": "plot",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+            "editType": "plot",
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "plot",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "size": {
+            "arrayOk": true,
+            "editType": "plot",
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "plot",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='funnelarea'))"
+        },
+        "textinfo": {
+          "description": "Determines what trace information appears on the graph. Flags are rendered in a fixed order; use `texttemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(hidesurface=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "extras": [
+            "none"
+          ],
+          "flags": [
+            "label",
+            "text",
+            "value",
+            "percent"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(textinfo=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "aspectratio": {
+          "description": "Sets the ratio between height and width",
+          "dflt": 1,
+          "editType": "plot",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(aspectratio=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+        },
+        "baseratio": {
+          "description": "Sets the ratio between bottom length and maximum top length.",
+          "dflt": 0.333,
+          "editType": "plot",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(baseratio=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
         "hoverlabel": {
           "align": {
@@ -55963,36 +46673,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
           "editType": "none",
           "font": {
@@ -56000,12 +46695,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -56016,12 +46706,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -56037,12 +46722,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "role": "object",
             "shadow": {
@@ -56051,24 +46731,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "style": {
               "arrayOk": true,
@@ -56080,12 +46750,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -56099,12 +46764,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "variant": {
               "arrayOk": true,
@@ -56120,12 +46780,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
             "weight": {
               "arrayOk": true,
@@ -56139,14 +46794,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='funnelarea'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -56155,12 +46805,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
           "role": "object",
           "showarrow": {
@@ -56168,291 +46813,211 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='funnelarea'))"
         },
-        "lighting": {
-          "ambient": {
-            "description": "Ambient light increases overall color visibility but can wash out the image.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        "insidetextfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "plot",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "diffuse": {
-            "description": "Represents the extent that incident rays are reflected in a range of angles.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "description": "Sets the font used for `textinfo` lying inside the sector.",
+          "editType": "plot",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+            "editType": "plot",
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "editType": "calc",
-          "fresnel": {
-            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
-            "dflt": 0.2,
-            "editType": "calc",
-            "max": 5,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "plot",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
           "role": "object",
-          "roughness": {
-            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
-            "dflt": 0.5,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "specular": {
-            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
-            "dflt": 0.05,
-            "editType": "calc",
-            "max": 2,
-            "min": 0,
+          "size": {
+            "arrayOk": true,
+            "editType": "plot",
+            "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='surface'))"
-        },
-        "lightposition": {
-          "editType": "calc",
-          "role": "object",
-          "x": {
-            "description": "Numeric vector, representing the X coordinate for each vertex.",
-            "dflt": 10,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "y": {
-            "description": "Numeric vector, representing the Y coordinate for each vertex.",
-            "dflt": 10000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "z": {
-            "description": "Numeric vector, representing the Z coordinate for each vertex.",
-            "dflt": 0,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
           },
-          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='surface'))"
-        },
-        "opacityscale": {
-          "description": "Sets the opacityscale. The opacityscale must be an array containing arrays mapping a normalized value to an opacity value. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 1], [0.5, 0.2], [1, 1]]` means that higher/lower values would have higher opacity values and those in the middle would be more transparent Alternatively, `opacityscale` may be a palette name string of the following list: 'min', 'max', 'extremes' and 'uniform'. The default is 'uniform'.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(opacityscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "ycalendar": {
-          "description": "Sets the calendar system to use with `y` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "plot",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
+          },
+          "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='funnelarea'))"
         },
-        "zcalendar": {
-          "description": "Sets the calendar system to use with `z` date data.",
-          "dflt": "gregorian",
+        "scalegroup": {
+          "description": "If there are multiple funnelareas that should be sized according to their totals, link them by providing a non-empty group id here shared by every trace in the same group.",
+          "dflt": "",
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(zcalendar=&lt;VALUE&gt;, selector=dict(type='surface'))"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(scalegroup=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='surface'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='surface'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='surface'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='funnelarea'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='surface'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='funnelarea'))"
       },
       "categories": [
-        "gl3d",
-        "2dMap",
+        "pie-like",
+        "funnelarea",
         "showLegend"
       ],
+      "layoutAttributes": {
+        "extendfunnelareacolors": {
+          "description": "If `true`, the funnelarea slice colors (whether given by `funnelareacolorway` or inherited from `colorway`) will be extended to three times its original length by first repeating every color 20% lighter then each color 20% darker. This is intended to reduce the likelihood of reusing the same color when you have many slices, but you can set `false` to disable. Colors provided in the trace, using `marker.colors`, are never extended.",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "boolean"
+        },
+        "funnelareacolorway": {
+          "description": "Sets the default funnelarea slice colors. Defaults to the main `colorway` used for trace colors. If you specify a new list here it can still be extended with lighter and darker colors, see `extendfunnelareacolors`.",
+          "editType": "calc",
+          "valType": "colorlist"
+        },
+        "hiddenlabels": {
+          "description": "hiddenlabels is the funnelarea & pie chart analog of visible:'legendonly' but it can contain many labels, and can simultaneously hide slices from several pies/funnelarea charts",
+          "editType": "calc",
+          "valType": "data_array"
+        }
+      },
       "meta": {
-        "description": "The data the describes the coordinates of the surface is set in `z`. Data in `z` should be a {2D array}. Coordinates in `x` and `y` can either be 1D {arrays} or {2D arrays} (e.g. to graph parametric surfaces). If not provided in `x` and `y`, the x and y coordinates are assumed to be linear starting at 0 with a unit step. The color scale corresponds to the `z` values by default. For custom color scales, use `surfacecolor` which should be a {2D array}, where its bounds can be controlled using `cmin` and `cmax`."
+        "description": "Visualize stages in a process using area-encoded trapezoids. This trace can be used to show data in a part-to-whole representation similar to a \"pie\" trace, wherein each item appears in a single stage. See also the \"funnel\" trace type for a different approach to visualizing funnel data."
       },
-      "type": "surface"
+      "type": "funnelarea"
     },
-    "mesh3d": {
-      "animatable": false,
+    "indicator": {
+      "animatable": true,
       "attributes": {
-        "type": "mesh3d",
+        "type": "indicator",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
         "uid": {
+          "anim": true,
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": false,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "legendgrouptitle": {
-          "editType": "style",
+        "title": {
+          "align": {
+            "description": "Sets the horizontal alignment of the title. It defaults to `center` except for bullet charts for which it defaults to right.",
+            "editType": "plot",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "center",
+              "right"
+            ],
+            "magic_underscores": "fig.update_traces(title_align=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          },
+          "editType": "plot",
           "font": {
             "color": {
-              "editType": "style",
+              "editType": "plot",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
+            "description": "Set the font used to display the title",
+            "editType": "plot",
             "family": {
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
+              "editType": "plot",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "style",
+              "editType": "plot",
               "extras": [
                 "none"
               ],
@@ -56462,37 +47027,37 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "role": "object",
             "shadow": {
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "style",
+              "editType": "plot",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "size": {
-              "editType": "style",
+              "editType": "plot",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "style",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "style",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -56500,12 +47065,12 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "style",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -56515,12 +47080,12 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "style",
+              "editType": "plot",
               "extras": [
                 "normal",
                 "bold"
@@ -56528,521 +47093,323 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(title_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='mesh3d'))"
+            "magic_underscores": "fig.update_traces(title_font=dict(...), selector=dict(type='indicator'))"
           },
           "role": "object",
           "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
+            "description": "Sets the title of this indicator.",
+            "editType": "plot",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "magic_underscores": "fig.update_traces(title_text=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='mesh3d'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
-          "dflt": 1,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x": {
-          "description": "Sets the X coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y": {
-          "description": "Sets the Y coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "z": {
-          "description": "Sets the Z coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "i": {
-          "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *first* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `i[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `i` represents a point in space, which is the first vertex of a triangle.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(i=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "isrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `i`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "j": {
-          "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *second* vertex of a triangle. For example, `{i[m], j[m], k[m]}`  together represent face m (triangle m) in the mesh, where `j[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `j` represents a point in space, which is the second vertex of a triangle.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(j=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "jsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `j`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "k": {
-          "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *third* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `k[m] = n` points to the triplet  `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `k` represents a point in space, which is the third vertex of a triangle.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(k=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "ksrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `k`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "facecolor": {
-          "description": "Sets the color of each face Overrides *color* and *vertexcolor*.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(facecolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "facecolorsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `facecolor`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "intensity": {
-          "description": "Sets the intensity values for vertices or cells as defined by `intensitymode`. It can be used for plotting fields on meshes.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(intensity=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "intensitysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `intensity`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(title=dict(...), selector=dict(type='indicator'))"
         },
-        "intensitymode": {
-          "description": "Determines the source of `intensity` values.",
-          "dflt": "vertex",
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
           "editType": "calc",
           "valType": "enumerated",
           "values": [
-            "vertex",
-            "cell"
+            true,
+            false,
+            "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(intensitymode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "vertexcolor": {
-          "description": "Sets the color of each vertex Overrides *color*. While Red, green and blue colors are in the range of 0 and 255; in the case of having vertex color data in RGBA format, the alpha color should be normalized to be between 0 and 1.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(vertexcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "vertexcolorsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `vertexcolor`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "text": {
-          "arrayOk": true,
-          "description": "Sets the text elements associated with the vertices. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Same as `text`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        "legendgrouptitle": {
+          "editType": "style",
+          "font": {
+            "color": {
+              "editType": "style",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "description": "Sets this legend group's title font.",
+            "editType": "style",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "style",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "style",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "size": {
+              "editType": "style",
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='indicator'))"
+          },
+          "role": "object",
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+          },
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='indicator'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
+        "mode": {
+          "description": "Determines how the value is displayed on the graph. `number` displays the value numerically in text. `delta` displays the difference to a reference value in text. Finally, `gauge` displays the value graphically on an axis.",
+          "dflt": "number",
           "editType": "calc",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
           "flags": [
-            "x",
-            "y",
-            "z",
-            "text",
-            "name"
+            "number",
+            "delta",
+            "gauge"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
+        "ids": {
+          "anim": true,
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
+        "value": {
+          "anim": true,
+          "description": "Sets the number to be displayed.",
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(value=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "scene": {
-          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
-          "dflt": "scene",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "coloraxis": {
-          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-          "dflt": null,
-          "editType": "calc",
-          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "color": {
-          "description": "Sets the color of the whole mesh",
-          "editType": "calc",
-          "valType": "color",
-          "magic_underscores": "fig.update_traces(color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='indicator'))"
         },
-        "colorbar": {
-          "bgcolor": {
-            "description": "Sets the color of padded area.",
-            "dflt": "rgba(0,0,0,0)",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "bordercolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "borderwidth": {
-            "description": "Sets the width (in px) or the border enclosing this color bar.",
+        "domain": {
+          "column": {
+            "description": "If there is a layout grid, use the domain for this column in the grid for this indicator trace.",
             "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "dtick": {
-            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "editType": "colorbars",
-          "exponentformat": {
-            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-            "dflt": "B",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "none",
-              "e",
-              "E",
-              "power",
-              "SI",
-              "B",
-              "SI extended"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "labelalias": {
-            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "len": {
-            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "lenmode": {
-            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-            "dflt": "fraction",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "minexponent": {
-            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-            "dflt": 3,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(domain_column=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "nticks": {
-            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+          "editType": "calc",
+          "role": "object",
+          "row": {
+            "description": "If there is a layout grid, use the domain for this row in the grid for this indicator trace.",
             "dflt": 0,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "orientation": {
-            "description": "Sets the orientation of the colorbar.",
-            "dflt": "v",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "h",
-              "v"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "outlinecolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "outlinewidth": {
-            "description": "Sets the width (in px) of the axis line.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "role": "object",
-          "separatethousands": {
-            "description": "If \"true\", even 4-digit integers are separated",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "magic_underscores": "fig.update_traces(domain_row=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "showexponent": {
-            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
+          "x": {
+            "description": "Sets the horizontal domain of this indicator trace (in plot fraction).",
+            "dflt": [
+              0,
+              1
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "showticklabels": {
-            "description": "Determines whether or not the tick labels are drawn.",
-            "dflt": true,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "showtickprefix": {
-            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
+            "editType": "calc",
+            "items": [
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              },
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              }
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "valType": "info_array",
+            "magic_underscores": "fig.update_traces(domain_x=list(...), selector=dict(type='indicator'))"
           },
-          "showticksuffix": {
-            "description": "Same as `showtickprefix` but for tick suffixes.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
+          "y": {
+            "description": "Sets the vertical domain of this indicator trace (in plot fraction).",
+            "dflt": [
+              0,
+              1
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-            "dflt": 30,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "thicknessmode": {
-            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-            "dflt": "pixels",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
+            "editType": "calc",
+            "items": [
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              },
+              {
+                "editType": "calc",
+                "max": 1,
+                "min": 0,
+                "valType": "number"
+              }
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "valType": "info_array",
+            "magic_underscores": "fig.update_traces(domain_y=list(...), selector=dict(type='indicator'))"
           },
-          "tick0": {
-            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "magic_underscores": "fig.update_traces(domain=dict(...), selector=dict(type='indicator'))"
+        },
+        "align": {
+          "description": "Sets the horizontal alignment of the `text` within the box. Note that this attribute has no effect if an angular gauge is displayed: in this case, it is always centered",
+          "editType": "plot",
+          "valType": "enumerated",
+          "values": [
+            "left",
+            "center",
+            "right"
+          ],
+          "magic_underscores": "fig.update_traces(align=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+        },
+        "delta": {
+          "decreasing": {
+            "color": {
+              "description": "Sets the color for increasing value.",
+              "dflt": "#FF4136",
+              "editType": "plot",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(delta_decreasing_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "tickangle": {
-            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-            "dflt": "auto",
-            "editType": "colorbars",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "tickcolor": {
-            "description": "Sets the tick color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "editType": "plot",
+            "role": "object",
+            "symbol": {
+              "description": "Sets the symbol to display for increasing value",
+              "dflt": "\u25bc",
+              "editType": "plot",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(delta_decreasing_symbol=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "magic_underscores": "fig.update_traces(delta_decreasing=dict(...), selector=dict(type='indicator'))"
           },
-          "tickfont": {
+          "editType": "calc",
+          "font": {
             "color": {
-              "editType": "colorbars",
+              "editType": "plot",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "description": "Sets the color bar's tick label font",
-            "editType": "colorbars",
+            "description": "Set the font used to display the delta",
+            "editType": "plot",
             "family": {
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "colorbars",
+              "editType": "plot",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "colorbars",
+              "editType": "plot",
               "extras": [
                 "none"
               ],
@@ -57052,37 +47419,37 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "role": "object",
             "shadow": {
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "colorbars",
+              "editType": "plot",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "size": {
-              "editType": "colorbars",
+              "editType": "plot",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -57090,12 +47457,12 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -57105,12 +47472,12 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "plot",
               "extras": [
                 "normal",
                 "bold"
@@ -57118,590 +47485,100 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='mesh3d'))"
-          },
-          "tickformat": {
-            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "tickformatstops": {
-            "items": {
-              "tickformatstop": {
-                "dtickrange": {
-                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "colorbars",
-                  "items": [
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    },
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "editType": "colorbars",
-                "enabled": {
-                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                  "dflt": true,
-                  "editType": "colorbars",
-                  "valType": "boolean"
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "value": {
-                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                  "dflt": "",
-                  "editType": "colorbars",
-                  "valType": "string"
-                }
-              }
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='mesh3d'))"
-          },
-          "ticklabeloverflow": {
-            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "allow",
-              "hide past div",
-              "hide past domain"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ticklabelposition": {
-            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-            "dflt": "outside",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              "outside top",
-              "inside top",
-              "outside left",
-              "inside left",
-              "outside right",
-              "inside right",
-              "outside bottom",
-              "inside bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ticklabelstep": {
-            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ticklen": {
-            "description": "Sets the tick length (in px).",
-            "dflt": 5,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "tickmode": {
-            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+              "magic_underscores": "fig.update_traces(delta_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "valType": "enumerated",
-            "values": [
-              "auto",
-              "linear",
-              "array"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "tickprefix": {
-            "description": "Sets a tick label prefix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ticks": {
-            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              ""
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ticksuffix": {
-            "description": "Sets a tick label suffix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ticktext": {
-            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickvals": {
-            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickwidth": {
-            "description": "Sets the tick width (in px).",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "magic_underscores": "fig.update_traces(delta_font=dict(...), selector=dict(type='indicator'))"
           },
-          "title": {
-            "editType": "colorbars",
-            "font": {
-              "color": {
-                "editType": "colorbars",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "description": "Sets this color bar's title font.",
-              "editType": "colorbars",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "size": {
-                "editType": "colorbars",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-              },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='mesh3d'))"
-            },
-            "role": "object",
-            "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "right",
-                "top",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "text": {
-              "description": "Sets the title of the color bar.",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "increasing": {
+            "color": {
+              "description": "Sets the color for increasing value.",
+              "dflt": "#3D9970",
+              "editType": "plot",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(delta_increasing_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='mesh3d'))"
-          },
-          "x": {
-            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "xanchor": {
-            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "xpad": {
-            "description": "Sets the amount of padding (in px) along the x direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "xref": {
-            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "y": {
-            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "yanchor": {
-            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "top",
-              "middle",
-              "bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "ypad": {
-            "description": "Sets the amount of padding (in px) along the y direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "yref": {
-            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='mesh3d'))"
-        },
-        "autocolorscale": {
-          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "showscale": {
-          "description": "Determines whether or not a colorbar is displayed for this trace.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
-          "dflt": false,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "cauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here `intensity`) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "cmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as `intensity` and if set, `cmin` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "cmid": {
-          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as `intensity`. Has no effect when `cauto` is `false`.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "cmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as `intensity` and if set, `cmax` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "alphahull": {
-          "description": "Determines how the mesh surface triangles are derived from the set of vertices (points) represented by the `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays are not supplied. For general use of `mesh3d` it is preferred that `i`, `j`, `k` are supplied. If *-1*, Delaunay triangulation is used, which is mainly suitable if the mesh is a single, more or less layer surface that is perpendicular to `delaunayaxis`. In case the `delaunayaxis` intersects the mesh surface at more than one point it will result triangles that are very long in the dimension of `delaunayaxis`. If *>0*, the alpha-shape algorithm is used. In this case, the positive `alphahull` value signals the use of the alpha-shape algorithm, _and_ its value acts as the parameter for the mesh fitting. If *0*,  the convex-hull algorithm is used. It is suitable for convex bodies or if the intention is to enclose the `x`, `y` and `z` point set into a convex hull.",
-          "dflt": -1,
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(alphahull=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "delaunayaxis": {
-          "description": "Sets the Delaunay axis, which is the axis that is perpendicular to the surface of the Delaunay triangulation. It has an effect if `i`, `j`, `k` are not provided and `alphahull` is set to indicate Delaunay triangulation.",
-          "dflt": "z",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "x",
-            "y",
-            "z"
-          ],
-          "magic_underscores": "fig.update_traces(delaunayaxis=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "contour": {
-          "color": {
-            "description": "Sets the color of the contour lines.",
-            "dflt": "#444",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(contour_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "editType": "calc",
-          "role": "object",
-          "show": {
-            "description": "Sets whether or not dynamic contours are shown on hover",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(contour_show=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "width": {
-            "description": "Sets the width of the contour lines.",
-            "dflt": 2,
-            "editType": "calc",
-            "max": 16,
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(contour_width=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "editType": "plot",
+            "role": "object",
+            "symbol": {
+              "description": "Sets the symbol to display for increasing value",
+              "dflt": "\u25b2",
+              "editType": "plot",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(delta_increasing_symbol=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "magic_underscores": "fig.update_traces(delta_increasing=dict(...), selector=dict(type='indicator'))"
           },
-          "magic_underscores": "fig.update_traces(contour=dict(...), selector=dict(type='mesh3d'))"
-        },
-        "flatshading": {
-          "description": "Determines whether or not normal smoothing is applied to the meshes, creating meshes with an angular, low-poly look via flat reflections.",
-          "dflt": false,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(flatshading=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
+          "position": {
+            "description": "Sets the position of delta with respect to the number.",
+            "dflt": "bottom",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
+              "top",
+              "bottom",
               "left",
-              "right",
-              "auto"
+              "right"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "magic_underscores": "fig.update_traces(delta_position=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+          "prefix": {
+            "description": "Sets a prefix appearing before the delta.",
+            "dflt": "",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(delta_prefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "reference": {
+            "description": "Sets the reference value to compute the delta. By default, it is set to the current value.",
+            "editType": "calc",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(delta_reference=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+          "relative": {
+            "description": "Show relative change",
+            "dflt": false,
+            "editType": "plot",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(delta_relative=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "bordercolor": {
-            "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "role": "object",
+          "suffix": {
+            "description": "Sets a suffix appearing next to the delta.",
+            "dflt": "",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(delta_suffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+          "valueformat": {
+            "description": "Sets the value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(delta_valueformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "editType": "none",
+          "magic_underscores": "fig.update_traces(delta=dict(...), selector=dict(type='indicator'))"
+        },
+        "number": {
+          "editType": "plot",
           "font": {
             "color": {
-              "arrayOk": true,
-              "editType": "none",
+              "editType": "plot",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
+            "description": "Set the font used to display main number",
+            "editType": "plot",
             "family": {
-              "arrayOk": true,
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
+              "editType": "plot",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "lineposition": {
-              "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "none",
+              "editType": "plot",
               "extras": [
                 "none"
               ],
@@ -57711,61 +47588,37 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "role": "object",
             "shadow": {
-              "arrayOk": true,
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "none",
+              "editType": "plot",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "size": {
-              "arrayOk": true,
-              "editType": "none",
+              "editType": "plot",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "style": {
-              "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "textcase": {
-              "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -57773,18 +47626,12 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "variant": {
-              "arrayOk": true,
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -57794,18 +47641,12 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
             "weight": {
-              "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "none",
+              "editType": "plot",
               "extras": [
                 "normal",
                 "bold"
@@ -57813,896 +47654,699 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(number_font_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='mesh3d'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='mesh3d'))"
-        },
-        "lighting": {
-          "ambient": {
-            "description": "Ambient light increases overall color visibility but can wash out the image.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "diffuse": {
-            "description": "Represents the extent that incident rays are reflected in a range of angles.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "editType": "calc",
-          "facenormalsepsilon": {
-            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-06,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "fresnel": {
-            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
-            "dflt": 0.2,
-            "editType": "calc",
-            "max": 5,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "role": "object",
-          "roughness": {
-            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
-            "dflt": 0.5,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "specular": {
-            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
-            "dflt": 0.05,
-            "editType": "calc",
-            "max": 2,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "magic_underscores": "fig.update_traces(number_font=dict(...), selector=dict(type='indicator'))"
           },
-          "vertexnormalsepsilon": {
-            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-12,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "prefix": {
+            "description": "Sets a prefix appearing before the number.",
+            "dflt": "",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(number_prefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='mesh3d'))"
-        },
-        "lightposition": {
-          "editType": "calc",
           "role": "object",
-          "x": {
-            "description": "Numeric vector, representing the X coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "y": {
-            "description": "Numeric vector, representing the Y coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "z": {
-            "description": "Numeric vector, representing the Z coordinate for each vertex.",
-            "dflt": 0,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-          },
-          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='mesh3d'))"
-        },
-        "xcalendar": {
-          "description": "Sets the calendar system to use with `x` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "ycalendar": {
-          "description": "Sets the calendar system to use with `y` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "zcalendar": {
-          "description": "Sets the calendar system to use with `z` date data.",
-          "dflt": "gregorian",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "chinese",
-            "coptic",
-            "discworld",
-            "ethiopian",
-            "gregorian",
-            "hebrew",
-            "islamic",
-            "jalali",
-            "julian",
-            "mayan",
-            "nanakshahi",
-            "nepali",
-            "persian",
-            "taiwan",
-            "thai",
-            "ummalqura"
-          ],
-          "magic_underscores": "fig.update_traces(zcalendar=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          "suffix": {
+            "description": "Sets a suffix appearing next to the number.",
+            "dflt": "",
+            "editType": "plot",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(number_suffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
+          "valueformat": {
+            "description": "Sets the value formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.",
+            "dflt": "",
+            "editType": "plot",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+            "magic_underscores": "fig.update_traces(number_valueformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='mesh3d'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='mesh3d'))"
-      },
-      "categories": [
-        "gl3d",
-        "showLegend"
-      ],
-      "meta": {
-        "description": "Draws sets of triangles with coordinates given by three 1-dimensional arrays in `x`, `y`, `z` and (1) a sets of `i`, `j`, `k` indices (2) Delaunay triangulation or (3) the Alpha-shape algorithm or (4) the Convex-hull algorithm"
-      },
-      "type": "mesh3d"
-    },
-    "cone": {
-      "animatable": false,
-      "attributes": {
-        "type": "cone",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": false,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          "magic_underscores": "fig.update_traces(number=dict(...), selector=dict(type='indicator'))"
         },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        "gauge": {
+          "axis": {
+            "dtick": {
+              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+              "editType": "plot",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(gauge_axis_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(gauge_axis_dtick=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "editType": "plot",
+            "exponentformat": {
+              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+              "dflt": "B",
+              "editType": "plot",
+              "valType": "enumerated",
+              "values": [
+                "none",
+                "e",
+                "E",
+                "power",
+                "SI",
+                "B",
+                "SI extended"
+              ],
+              "magic_underscores": "fig.update_traces(gauge_axis_exponentformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "labelalias": {
+              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+              "dflt": false,
+              "editType": "plot",
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(gauge_axis_labelalias=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "minexponent": {
+              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+              "dflt": 3,
+              "editType": "plot",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(gauge_axis_minexponent=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+            "nticks": {
+              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+              "dflt": 0,
+              "editType": "plot",
+              "min": 0,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(gauge_axis_nticks=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "range": {
+              "description": "Sets the range of this axis.",
+              "editType": "plot",
+              "items": [
+                {
+                  "editType": "plot",
+                  "valType": "number"
+                },
+                {
+                  "editType": "plot",
+                  "valType": "number"
+                }
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "valType": "info_array",
+              "magic_underscores": "fig.update_traces(gauge_axis_range=list(...), selector=dict(type='indicator'))"
             },
             "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
-            },
-            "size": {
-              "editType": "style",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "separatethousands": {
+              "description": "If \"true\", even 4-digit integers are separated",
+              "dflt": false,
+              "editType": "plot",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(gauge_axis_separatethousands=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
+            "showexponent": {
+              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+              "dflt": "all",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "all",
+                "first",
+                "last",
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(gauge_axis_showexponent=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
+            "showticklabels": {
+              "description": "Determines whether or not the tick labels are drawn.",
+              "dflt": true,
+              "editType": "plot",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(gauge_axis_showticklabels=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "showtickprefix": {
+              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+              "dflt": "all",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "all",
+                "first",
+                "last",
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(gauge_axis_showtickprefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
+            "showticksuffix": {
+              "description": "Same as `showtickprefix` but for tick suffixes.",
+              "dflt": "all",
+              "editType": "plot",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "all",
+                "first",
+                "last",
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(gauge_axis_showticksuffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "tick0": {
+              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+              "editType": "plot",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(gauge_axis_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(gauge_axis_tick0=&lt;VALUE&gt;, selector=dict(type='indicator'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='cone'))"
-          },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='cone'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
-          "dflt": 1,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x": {
-          "description": "Sets the x coordinates of the vector field and of the displayed cones.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y": {
-          "description": "Sets the y coordinates of the vector field and of the displayed cones.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "z": {
-          "description": "Sets the z coordinates of the vector field and of the displayed cones.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "u": {
-          "description": "Sets the x components of the vector field.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(u=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "usrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `u`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "v": {
-          "description": "Sets the y components of the vector field.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(v=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "vsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `v`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "w": {
-          "description": "Sets the z components of the vector field.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(w=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "wsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `w`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "text": {
-          "arrayOk": true,
-          "description": "Sets the text elements associated with the cones. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertext": {
-          "arrayOk": true,
-          "description": "Same as `text`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "x+y+z+norm+text+name",
-          "editType": "calc",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "x",
-            "y",
-            "z",
-            "u",
-            "v",
-            "w",
-            "norm",
-            "text",
-            "name"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `norm` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "uhoverformat": {
-          "description": "Sets the hover text formatting rulefor `u`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "vhoverformat": {
-          "description": "Sets the hover text formatting rulefor `v`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(vhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "whoverformat": {
-          "description": "Sets the hover text formatting rulefor `w`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(whoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "scene": {
-          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
-          "dflt": "scene",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "coloraxis": {
-          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-          "dflt": null,
-          "editType": "calc",
-          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "colorbar": {
+            "tickangle": {
+              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+              "dflt": "auto",
+              "editType": "plot",
+              "valType": "angle",
+              "magic_underscores": "fig.update_traces(gauge_axis_tickangle=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "tickcolor": {
+              "description": "Sets the tick color.",
+              "dflt": "#444",
+              "editType": "plot",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(gauge_axis_tickcolor=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "tickfont": {
+              "color": {
+                "editType": "plot",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "description": "Sets the color bar's tick label font",
+              "editType": "plot",
+              "family": {
+                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                "editType": "plot",
+                "noBlank": true,
+                "strict": true,
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_family=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "lineposition": {
+                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                "dflt": "none",
+                "editType": "plot",
+                "extras": [
+                  "none"
+                ],
+                "flags": [
+                  "under",
+                  "over",
+                  "through"
+                ],
+                "valType": "flaglist",
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "role": "object",
+              "shadow": {
+                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                "dflt": "none",
+                "editType": "plot",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "size": {
+                "editType": "plot",
+                "min": 1,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_size=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "style": {
+                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                "dflt": "normal",
+                "editType": "plot",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "italic"
+                ],
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_style=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "textcase": {
+                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                "dflt": "normal",
+                "editType": "plot",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "plot",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "plot",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(gauge_axis_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "magic_underscores": "fig.update_traces(gauge_axis_tickfont=dict(...), selector=dict(type='indicator'))"
+            },
+            "tickformat": {
+              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+              "dflt": "",
+              "editType": "plot",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(gauge_axis_tickformat=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "tickformatstops": {
+              "items": {
+                "tickformatstop": {
+                  "dtickrange": {
+                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                    "editType": "plot",
+                    "items": [
+                      {
+                        "editType": "plot",
+                        "valType": "any"
+                      },
+                      {
+                        "editType": "plot",
+                        "valType": "any"
+                      }
+                    ],
+                    "valType": "info_array"
+                  },
+                  "editType": "plot",
+                  "enabled": {
+                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                    "dflt": true,
+                    "editType": "plot",
+                    "valType": "boolean"
+                  },
+                  "name": {
+                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                    "editType": "plot",
+                    "valType": "string"
+                  },
+                  "role": "object",
+                  "templateitemname": {
+                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                    "editType": "plot",
+                    "valType": "string"
+                  },
+                  "value": {
+                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                    "dflt": "",
+                    "editType": "plot",
+                    "valType": "string"
+                  }
+                }
+              },
+              "role": "object",
+              "magic_underscores": "fig.update_traces(gauge_axis_tickformatstops=list(...), selector=dict(type='indicator'))"
+            },
+            "ticklabelstep": {
+              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+              "dflt": 1,
+              "editType": "plot",
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(gauge_axis_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "ticklen": {
+              "description": "Sets the tick length (in px).",
+              "dflt": 5,
+              "editType": "plot",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(gauge_axis_ticklen=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "tickmode": {
+              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+              "editType": "plot",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(gauge_axis_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "valType": "enumerated",
+              "values": [
+                "auto",
+                "linear",
+                "array"
+              ],
+              "magic_underscores": "fig.update_traces(gauge_axis_tickmode=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "tickprefix": {
+              "description": "Sets a tick label prefix.",
+              "dflt": "",
+              "editType": "plot",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(gauge_axis_tickprefix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "ticks": {
+              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+              "dflt": "outside",
+              "editType": "plot",
+              "valType": "enumerated",
+              "values": [
+                "outside",
+                "inside",
+                ""
+              ],
+              "magic_underscores": "fig.update_traces(gauge_axis_ticks=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "ticksuffix": {
+              "description": "Sets a tick label suffix.",
+              "dflt": "",
+              "editType": "plot",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(gauge_axis_ticksuffix=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "ticktext": {
+              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+              "editType": "plot",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(gauge_axis_ticktext=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "tickvals": {
+              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+              "editType": "plot",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(gauge_axis_tickvals=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "tickwidth": {
+              "description": "Sets the tick width (in px).",
+              "dflt": 1,
+              "editType": "plot",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(gauge_axis_tickwidth=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "visible": {
+              "description": "A single toggle to hide the axis while preserving interaction like dragging. Default is true when a cheater plot is present on the axis, otherwise false",
+              "dflt": true,
+              "editType": "plot",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(gauge_axis_visible=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "magic_underscores": "fig.update_traces(gauge_axis=dict(...), selector=dict(type='indicator'))"
+          },
+          "bar": {
+            "color": {
+              "description": "Sets the background color of the arc.",
+              "dflt": "green",
+              "editType": "plot",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(gauge_bar_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "description": "Set the appearance of the gauge's value",
+            "editType": "calc",
+            "line": {
+              "color": {
+                "description": "Sets the color of the line enclosing each sector.",
+                "dflt": "#444",
+                "editType": "plot",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(gauge_bar_line_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "editType": "calc",
+              "role": "object",
+              "width": {
+                "description": "Sets the width (in px) of the line enclosing each sector.",
+                "dflt": 0,
+                "editType": "plot",
+                "min": 0,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(gauge_bar_line_width=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "magic_underscores": "fig.update_traces(gauge_bar_line=dict(...), selector=dict(type='indicator'))"
+            },
+            "role": "object",
+            "thickness": {
+              "description": "Sets the thickness of the bar as a fraction of the total thickness of the gauge.",
+              "dflt": 1,
+              "editType": "plot",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(gauge_bar_thickness=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "magic_underscores": "fig.update_traces(gauge_bar=dict(...), selector=dict(type='indicator'))"
+          },
           "bgcolor": {
-            "description": "Sets the color of padded area.",
-            "dflt": "rgba(0,0,0,0)",
-            "editType": "colorbars",
+            "description": "Sets the gauge background color.",
+            "editType": "plot",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "magic_underscores": "fig.update_traces(gauge_bgcolor=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
           "bordercolor": {
-            "description": "Sets the axis line color.",
+            "description": "Sets the color of the border enclosing the gauge.",
             "dflt": "#444",
-            "editType": "colorbars",
+            "editType": "plot",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "magic_underscores": "fig.update_traces(gauge_bordercolor=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
           "borderwidth": {
-            "description": "Sets the width (in px) or the border enclosing this color bar.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "dtick": {
-            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
-            },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "editType": "colorbars",
-          "exponentformat": {
-            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-            "dflt": "B",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "none",
-              "e",
-              "E",
-              "power",
-              "SI",
-              "B",
-              "SI extended"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "labelalias": {
-            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "len": {
-            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "lenmode": {
-            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-            "dflt": "fraction",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "minexponent": {
-            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-            "dflt": 3,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "nticks": {
-            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "orientation": {
-            "description": "Sets the orientation of the colorbar.",
-            "dflt": "v",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "h",
-              "v"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "outlinecolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "outlinewidth": {
-            "description": "Sets the width (in px) of the axis line.",
+            "description": "Sets the width (in px) of the border enclosing the gauge.",
             "dflt": 1,
-            "editType": "colorbars",
+            "editType": "plot",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "magic_underscores": "fig.update_traces(gauge_borderwidth=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
+          "description": "The gauge of the Indicator plot.",
+          "editType": "plot",
           "role": "object",
-          "separatethousands": {
-            "description": "If \"true\", even 4-digit integers are separated",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "showexponent": {
-            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "showticklabels": {
-            "description": "Determines whether or not the tick labels are drawn.",
-            "dflt": true,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "showtickprefix": {
-            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "showticksuffix": {
-            "description": "Same as `showtickprefix` but for tick suffixes.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-            "dflt": 30,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "thicknessmode": {
-            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-            "dflt": "pixels",
-            "editType": "colorbars",
+          "shape": {
+            "description": "Set the shape of the gauge",
+            "dflt": "angular",
+            "editType": "plot",
             "valType": "enumerated",
             "values": [
-              "fraction",
-              "pixels"
+              "angular",
+              "bullet"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "magic_underscores": "fig.update_traces(gauge_shape=&lt;VALUE&gt;, selector=dict(type='indicator'))"
           },
-          "tick0": {
-            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          "steps": {
+            "items": {
+              "step": {
+                "color": {
+                  "description": "Sets the background color of the arc.",
+                  "editType": "plot",
+                  "valType": "color"
+                },
+                "editType": "calc",
+                "line": {
+                  "color": {
+                    "description": "Sets the color of the line enclosing each sector.",
+                    "dflt": "#444",
+                    "editType": "plot",
+                    "valType": "color"
+                  },
+                  "editType": "calc",
+                  "role": "object",
+                  "width": {
+                    "description": "Sets the width (in px) of the line enclosing each sector.",
+                    "dflt": 0,
+                    "editType": "plot",
+                    "min": 0,
+                    "valType": "number"
+                  }
+                },
+                "name": {
+                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                  "editType": "none",
+                  "valType": "string"
+                },
+                "range": {
+                  "description": "Sets the range of this axis.",
+                  "editType": "plot",
+                  "items": [
+                    {
+                      "editType": "plot",
+                      "valType": "number"
+                    },
+                    {
+                      "editType": "plot",
+                      "valType": "number"
+                    }
+                  ],
+                  "valType": "info_array"
+                },
+                "role": "object",
+                "templateitemname": {
+                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                  "editType": "calc",
+                  "valType": "string"
+                },
+                "thickness": {
+                  "description": "Sets the thickness of the bar as a fraction of the total thickness of the gauge.",
+                  "dflt": 1,
+                  "editType": "plot",
+                  "max": 1,
+                  "min": 0,
+                  "valType": "number"
+                }
+              }
             },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "tickangle": {
-            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-            "dflt": "auto",
-            "editType": "colorbars",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "role": "object",
+            "magic_underscores": "fig.update_traces(gauge_steps=list(...), selector=dict(type='indicator'))"
           },
-          "tickcolor": {
-            "description": "Sets the tick color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          "threshold": {
+            "editType": "plot",
+            "line": {
+              "color": {
+                "description": "Sets the color of the threshold line.",
+                "dflt": "#444",
+                "editType": "plot",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(gauge_threshold_line_color=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "editType": "plot",
+              "role": "object",
+              "width": {
+                "description": "Sets the width (in px) of the threshold line.",
+                "dflt": 1,
+                "editType": "plot",
+                "min": 0,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(gauge_threshold_line_width=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+              },
+              "magic_underscores": "fig.update_traces(gauge_threshold_line=dict(...), selector=dict(type='indicator'))"
+            },
+            "role": "object",
+            "thickness": {
+              "description": "Sets the thickness of the threshold line as a fraction of the thickness of the gauge.",
+              "dflt": 0.85,
+              "editType": "plot",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(gauge_threshold_thickness=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "value": {
+              "description": "Sets a treshold value drawn as a line.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(gauge_threshold_value=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+            },
+            "magic_underscores": "fig.update_traces(gauge_threshold=dict(...), selector=dict(type='indicator'))"
           },
-          "tickfont": {
+          "magic_underscores": "fig.update_traces(gauge=dict(...), selector=dict(type='indicator'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='indicator'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='indicator'))"
+      },
+      "categories": [
+        "svg",
+        "noOpacity",
+        "noHover"
+      ],
+      "meta": {
+        "description": "An indicator is used to visualize a single `value` along with some contextual information such as `steps` or a `threshold`, using a combination of three visual elements: a number, a delta, and/or a gauge. Deltas are taken with respect to a `reference`. Gauges can be either angular or bullet (aka linear) gauges."
+      },
+      "type": "indicator"
+    },
+    "scatter3d": {
+      "animatable": false,
+      "attributes": {
+        "type": "scatter3d",
+        "name": {
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "uid": {
+          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            true,
+            false,
+            "legendonly"
+          ],
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": true,
+          "editType": "style",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "legendgrouptitle": {
+          "editType": "style",
+          "font": {
             "color": {
-              "editType": "colorbars",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "description": "Sets the color bar's tick label font",
-            "editType": "colorbars",
+            "description": "Sets this legend group's title font.",
+            "editType": "style",
             "family": {
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "colorbars",
+              "editType": "style",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "colorbars",
+              "editType": "style",
               "extras": [
                 "none"
               ],
@@ -58712,37 +48356,37 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "role": "object",
             "shadow": {
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "colorbars",
+              "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "size": {
-              "editType": "colorbars",
+              "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -58750,12 +48394,12 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "style",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -58765,215 +48409,516 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "style",
               "extras": [
                 "normal",
                 "bold"
               ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='scatter3d'))"
+          },
+          "role": "object",
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='scatter3d'))"
+        },
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "mode": {
+          "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points and the trace is not stacked then the default is *lines+markers*. Otherwise, *lines*.",
+          "dflt": "lines+markers",
+          "editType": "calc",
+          "extras": [
+            "none"
+          ],
+          "flags": [
+            "lines",
+            "markers",
+            "text"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "x": {
+          "description": "Sets the x coordinates.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "y": {
+          "description": "Sets the y coordinates.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "z": {
+          "description": "Sets the z coordinates.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "surfacecolor": {
+          "description": "Sets the surface fill color.",
+          "editType": "calc",
+          "valType": "color",
+          "magic_underscores": "fig.update_traces(surfacecolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "text": {
+          "arrayOk": true,
+          "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "textposition": {
+          "arrayOk": true,
+          "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
+          "dflt": "top center",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "top left",
+            "top center",
+            "top right",
+            "middle left",
+            "middle center",
+            "middle right",
+            "bottom left",
+            "bottom center",
+            "bottom right"
+          ],
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "texttemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. ",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "texttemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "hovertext": {
+          "arrayOk": true,
+          "description": "Sets text elements associated with each (x,y,z) triplet. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y,z) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "hoverinfo": {
+          "arrayOk": true,
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "dflt": "all",
+          "editType": "calc",
+          "extras": [
+            "all",
+            "none",
+            "skip"
+          ],
+          "flags": [
+            "x",
+            "y",
+            "z",
+            "text",
+            "name"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "hovertemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "meta": {
+          "arrayOk": true,
+          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "customdata": {
+          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "scene": {
+          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
+          "dflt": "scene",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "marker": {
+          "autocolorscale": {
+            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+            "dflt": true,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "cauto": {
+            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
+            "dflt": true,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "cmax": {
+            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "cmid": {
+            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "cmin": {
+            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "color": {
+            "arrayOk": true,
+            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "coloraxis": {
+            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+            "dflt": null,
+            "editType": "calc",
+            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+            "valType": "subplotid",
+            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "colorbar": {
+            "bgcolor": {
+              "description": "Sets the color of padded area.",
+              "dflt": "rgba(0,0,0,0)",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "bordercolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "borderwidth": {
+              "description": "Sets the width (in px) or the border enclosing this color bar.",
+              "dflt": 0,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "dtick": {
+              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+              "editType": "calc",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "editType": "calc",
+            "exponentformat": {
+              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+              "dflt": "B",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "none",
+                "e",
+                "E",
+                "power",
+                "SI",
+                "B",
+                "SI extended"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "labelalias": {
+              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "len": {
+              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "lenmode": {
+              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+              "dflt": "fraction",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "minexponent": {
+              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+              "dflt": 3,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "nticks": {
+              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+              "dflt": 0,
+              "editType": "calc",
+              "min": 0,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "orientation": {
+              "description": "Sets the orientation of the colorbar.",
+              "dflt": "v",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "h",
+                "v"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "outlinecolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "outlinewidth": {
+              "description": "Sets the width (in px) of the axis line.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "role": "object",
+            "separatethousands": {
+              "description": "If \"true\", even 4-digit integers are separated",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showexponent": {
+              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showticklabels": {
+              "description": "Determines whether or not the tick labels are drawn.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showtickprefix": {
+              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showticksuffix": {
+              "description": "Same as `showtickprefix` but for tick suffixes.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "thickness": {
+              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+              "dflt": 30,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "thicknessmode": {
+              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+              "dflt": "pixels",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='cone'))"
-          },
-          "tickformat": {
-            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "tickformatstops": {
-            "items": {
-              "tickformatstop": {
-                "dtickrange": {
-                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "colorbars",
-                  "items": [
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    },
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "editType": "colorbars",
-                "enabled": {
-                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                  "dflt": true,
-                  "editType": "colorbars",
-                  "valType": "boolean"
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "value": {
-                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                  "dflt": "",
-                  "editType": "colorbars",
-                  "valType": "string"
-                }
-              }
+            "tick0": {
+              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+              "editType": "calc",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='cone'))"
-          },
-          "ticklabeloverflow": {
-            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "allow",
-              "hide past div",
-              "hide past domain"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ticklabelposition": {
-            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-            "dflt": "outside",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              "outside top",
-              "inside top",
-              "outside left",
-              "inside left",
-              "outside right",
-              "inside right",
-              "outside bottom",
-              "inside bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ticklabelstep": {
-            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ticklen": {
-            "description": "Sets the tick length (in px).",
-            "dflt": 5,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "tickmode": {
-            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "tickangle": {
+              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+              "dflt": "auto",
+              "editType": "calc",
+              "valType": "angle",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "valType": "enumerated",
-            "values": [
-              "auto",
-              "linear",
-              "array"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "tickprefix": {
-            "description": "Sets a tick label prefix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ticks": {
-            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              ""
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ticksuffix": {
-            "description": "Sets a tick label suffix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ticktext": {
-            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickvals": {
-            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickwidth": {
-            "description": "Sets the tick width (in px).",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "title": {
-            "editType": "colorbars",
-            "font": {
+            "tickcolor": {
+              "description": "Sets the tick color.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickfont": {
               "color": {
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
-              "description": "Sets this color bar's title font.",
-              "editType": "colorbars",
+              "description": "Sets the color bar's tick label font",
+              "editType": "calc",
               "family": {
                 "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
+                "editType": "calc",
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
                 "dflt": "none",
-                "editType": "colorbars",
+                "editType": "calc",
                 "extras": [
                   "none"
                 ],
@@ -58983,37 +48928,37 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
               "role": "object",
               "shadow": {
                 "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
                 "dflt": "none",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
               "size": {
-                "editType": "colorbars",
+                "editType": "calc",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "enumerated",
                 "values": [
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -59021,12 +48966,12 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -59036,12 +48981,12 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "extras": [
                   "normal",
                   "bold"
@@ -59049,1739 +48994,1708 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
-              },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='cone'))"
-            },
-            "role": "object",
-            "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "right",
-                "top",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='cone'))"
-            },
-            "text": {
-              "description": "Sets the title of the color bar.",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='cone'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='cone'))"
-          },
-          "x": {
-            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "xanchor": {
-            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "xpad": {
-            "description": "Sets the amount of padding (in px) along the x direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "xref": {
-            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "y": {
-            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "yanchor": {
-            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "top",
-              "middle",
-              "bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "ypad": {
-            "description": "Sets the amount of padding (in px) along the y direction.",
-            "dflt": 10,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "yref": {
-            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='cone'))"
-        },
-        "autocolorscale": {
-          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "showscale": {
-          "description": "Determines whether or not a colorbar is displayed for this trace.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
-          "dflt": false,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "cauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here u/v/w norm) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "cmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmin` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "cmid": {
-          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as u/v/w norm. Has no effect when `cauto` is `false`.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "cmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmax` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "anchor": {
-          "description": "Sets the cones' anchor with respect to their x/y/z positions. Note that *cm* denote the cone's center of mass which corresponds to 1/4 from the tail to tip.",
-          "dflt": "cm",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "tip",
-            "tail",
-            "cm",
-            "center"
-          ],
-          "magic_underscores": "fig.update_traces(anchor=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "hoverlabel": {
-          "align": {
-            "arrayOk": true,
-            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
-            "dflt": "auto",
-            "editType": "none",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "right",
-              "auto"
-            ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bgcolor": {
-            "arrayOk": true,
-            "description": "Sets the background color of the hover labels for this trace",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "bordercolor": {
-            "arrayOk": true,
-            "description": "Sets the border color of the hover labels for this trace.",
-            "editType": "none",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "none",
-          "font": {
-            "color": {
-              "arrayOk": true,
-              "editType": "none",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "description": "Sets the font used in hover labels.",
-            "editType": "none",
-            "family": {
-              "arrayOk": true,
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "none",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "lineposition": {
-              "arrayOk": true,
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "none",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
-              ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "shadow": {
-              "arrayOk": true,
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "none",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='scatter3d'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+            "tickformat": {
+              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+              "dflt": "",
+              "editType": "calc",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "size": {
-              "arrayOk": true,
-              "editType": "none",
-              "min": 1,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "tickformatstops": {
+              "items": {
+                "tickformatstop": {
+                  "dtickrange": {
+                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                    "editType": "calc",
+                    "items": [
+                      {
+                        "editType": "calc",
+                        "valType": "any"
+                      },
+                      {
+                        "editType": "calc",
+                        "valType": "any"
+                      }
+                    ],
+                    "valType": "info_array"
+                  },
+                  "editType": "calc",
+                  "enabled": {
+                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                    "dflt": true,
+                    "editType": "calc",
+                    "valType": "boolean"
+                  },
+                  "name": {
+                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                    "editType": "calc",
+                    "valType": "string"
+                  },
+                  "role": "object",
+                  "templateitemname": {
+                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                    "editType": "calc",
+                    "valType": "string"
+                  },
+                  "value": {
+                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                    "dflt": "",
+                    "editType": "calc",
+                    "valType": "string"
+                  }
+                }
+              },
+              "role": "object",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='scatter3d'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+            "ticklabeloverflow": {
+              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "allow",
+                "hide past div",
+                "hide past domain"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "style": {
-              "arrayOk": true,
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "none",
+            "ticklabelposition": {
+              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+              "dflt": "outside",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "outside",
+                "inside",
+                "outside top",
+                "inside top",
+                "outside left",
+                "inside left",
+                "outside right",
+                "inside right",
+                "outside bottom",
+                "inside bottom"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+            "ticklabelstep": {
+              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "textcase": {
-              "arrayOk": true,
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "none",
+            "ticklen": {
+              "description": "Sets the tick length (in px).",
+              "dflt": 5,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickmode": {
+              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "auto",
+                "linear",
+                "array"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+            "tickprefix": {
+              "description": "Sets a tick label prefix.",
+              "dflt": "",
+              "editType": "calc",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "variant": {
-              "arrayOk": true,
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "none",
+            "ticks": {
+              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+              "dflt": "",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "outside",
+                "inside",
+                ""
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+            "ticksuffix": {
+              "description": "Sets a tick label suffix.",
+              "dflt": "",
+              "editType": "calc",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "weight": {
-              "arrayOk": true,
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "none",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            "ticktext": {
+              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+            "tickvals": {
+              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='cone'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='cone'))"
-        },
-        "lighting": {
-          "ambient": {
-            "description": "Ambient light increases overall color visibility but can wash out the image.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "diffuse": {
-            "description": "Represents the extent that incident rays are reflected in a range of angles.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "editType": "calc",
-          "facenormalsepsilon": {
-            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-06,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "fresnel": {
-            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
-            "dflt": 0.2,
-            "editType": "calc",
-            "max": 5,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "role": "object",
-          "roughness": {
-            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
-            "dflt": 0.5,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "specular": {
-            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
-            "dflt": 0.05,
-            "editType": "calc",
-            "max": 2,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "vertexnormalsepsilon": {
-            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-12,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='cone'))"
-        },
-        "lightposition": {
-          "editType": "calc",
-          "role": "object",
-          "x": {
-            "description": "Numeric vector, representing the X coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "y": {
-            "description": "Numeric vector, representing the Y coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "z": {
-            "description": "Numeric vector, representing the Z coordinate for each vertex.",
-            "dflt": 0,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='cone'))"
-        },
-        "sizemode": {
-          "description": "Determines whether `sizeref` is set as a *scaled* (i.e unitless) scalar (normalized by the max u/v/w norm in the vector field) or as *absolute* value (in the same units as the vector field). To display sizes in actual vector length use *raw*.",
-          "dflt": "scaled",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "scaled",
-            "absolute",
-            "raw"
-          ],
-          "magic_underscores": "fig.update_traces(sizemode=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "sizeref": {
-          "description": "Adjusts the cone size scaling. The size of the cones is determined by their u/v/w norm multiplied a factor and `sizeref`. This factor (computed internally) corresponds to the minimum \"time\" to travel across two successive x/y/z positions at the average velocity of those two successive positions. All cones in a given trace use the same factor. With `sizemode` set to *raw*, its default value is *1*. With `sizemode` set to *scaled*, `sizeref` is unitless, its default value is *0.5*. With `sizemode` set to *absolute*, `sizeref` has the same units as the u/v/w vector field, its the default value is half the sample's maximum vector norm.",
-          "editType": "calc",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(sizeref=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='cone'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='cone'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='cone'))"
-        },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='cone'))"
-      },
-      "categories": [
-        "gl3d",
-        "showLegend"
-      ],
-      "meta": {
-        "description": "Use cone traces to visualize vector fields.  Specify a vector field using 6 1D arrays, 3 position arrays `x`, `y` and `z` and 3 vector component arrays `u`, `v`, `w`. The cones are drawn exactly at the positions given by `x`, `y` and `z`."
-      },
-      "type": "cone"
-    },
-    "streamtube": {
-      "animatable": false,
-      "attributes": {
-        "type": "streamtube",
-        "name": {
-          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "uid": {
-          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "visible": {
-          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            true,
-            false,
-            "legendonly"
-          ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "showlegend": {
-          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": false,
-          "editType": "style",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "legend": {
-          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
-          "dflt": "legend",
-          "editType": "style",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "legendrank": {
-          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
-          "dflt": 1000,
-          "editType": "style",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "legendgroup": {
-          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
-          "dflt": "",
-          "editType": "style",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "legendgrouptitle": {
-          "editType": "style",
-          "font": {
-            "color": {
-              "editType": "style",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "tickwidth": {
+              "description": "Sets the tick width (in px).",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "title": {
+              "editType": "calc",
+              "font": {
+                "color": {
+                  "editType": "calc",
+                  "valType": "color",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "description": "Sets this color bar's title font.",
+                "editType": "calc",
+                "family": {
+                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                  "editType": "calc",
+                  "noBlank": true,
+                  "strict": true,
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "lineposition": {
+                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                  "dflt": "none",
+                  "editType": "calc",
+                  "extras": [
+                    "none"
+                  ],
+                  "flags": [
+                    "under",
+                    "over",
+                    "through"
+                  ],
+                  "valType": "flaglist",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "role": "object",
+                "shadow": {
+                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                  "dflt": "none",
+                  "editType": "calc",
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "size": {
+                  "editType": "calc",
+                  "min": 1,
+                  "valType": "number",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "style": {
+                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "italic"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "textcase": {
+                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "word caps",
+                    "upper",
+                    "lower"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "variant": {
+                  "description": "Sets the variant of the font.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "small-caps",
+                    "all-small-caps",
+                    "all-petite-caps",
+                    "petite-caps",
+                    "unicase"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "weight": {
+                  "description": "Sets the weight (or boldness) of the font.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "extras": [
+                    "normal",
+                    "bold"
+                  ],
+                  "max": 1000,
+                  "min": 1,
+                  "valType": "integer",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='scatter3d'))"
+              },
+              "role": "object",
+              "side": {
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "right",
+                  "top",
+                  "bottom"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "text": {
+                "description": "Sets the title of the color bar.",
+                "editType": "calc",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='scatter3d'))"
             },
-            "description": "Sets this legend group's title font.",
-            "editType": "style",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "style",
-              "noBlank": true,
-              "strict": true,
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "x": {
+              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "style",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+            "xanchor": {
+              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "left",
+                "center",
+                "right"
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "style",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "size": {
-              "editType": "style",
-              "min": 1,
+            "xpad": {
+              "description": "Sets the amount of padding (in px) along the x direction.",
+              "dflt": 10,
+              "editType": "calc",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "style",
+            "xref": {
+              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+              "dflt": "paper",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "container",
+                "paper"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "style",
+            "y": {
+              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "yanchor": {
+              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "top",
+                "middle",
+                "bottom"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "style",
+            "ypad": {
+              "description": "Sets the amount of padding (in px) along the y direction.",
+              "dflt": 10,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "yref": {
+              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+              "dflt": "paper",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
-              ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "style",
-              "extras": [
-                "normal",
-                "bold"
+                "container",
+                "paper"
               ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scatter3d'))"
           },
-          "role": "object",
-          "text": {
-            "description": "Sets the title of the legend group.",
-            "dflt": "",
-            "editType": "style",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "colorscale": {
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "autocolorscale": false,
+              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "colorscale",
+            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='streamtube'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
-          "dflt": 1,
-          "editType": "calc",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "x": {
-          "description": "Sets the x coordinates of the vector field.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "y": {
-          "description": "Sets the y coordinates of the vector field.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "z": {
-          "description": "Sets the z coordinates of the vector field.",
-          "editType": "calc+clearAxisTypes",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "u": {
-          "description": "Sets the x components of the vector field.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(u=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "usrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `u`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "v": {
-          "description": "Sets the y components of the vector field.",
           "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(v=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "vsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `v`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "w": {
-          "description": "Sets the z components of the vector field.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(w=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "wsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `w`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "text": {
-          "description": "Sets a text element associated with this trace. If trace `hoverinfo` contains a *text* flag, this text element will be seen in all hover labels. Note that streamtube traces do not support array `text` values.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "hovertext": {
-          "description": "Same as `text`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "hoverinfo": {
-          "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "x+y+z+norm+text+name",
-          "editType": "calc",
-          "extras": [
-            "all",
-            "none",
-            "skip"
-          ],
-          "flags": [
-            "x",
-            "y",
-            "z",
-            "u",
-            "v",
-            "w",
-            "norm",
-            "divergence",
-            "text",
-            "name"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "hovertemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `tubex`, `tubey`, `tubez`, `tubeu`, `tubev`, `tubew`, `norm` and `divergence`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "hovertemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "uhoverformat": {
-          "description": "Sets the hover text formatting rulefor `u`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(uhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "vhoverformat": {
-          "description": "Sets the hover text formatting rulefor `v`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(vhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "whoverformat": {
-          "description": "Sets the hover text formatting rulefor `w`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
-          "dflt": "",
-          "editType": "none",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(whoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "meta": {
-          "arrayOk": true,
-          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
-          "editType": "plot",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "customdata": {
-          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "scene": {
-          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
-          "dflt": "scene",
-          "editType": "calc+clearAxisTypes",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "coloraxis": {
-          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-          "dflt": null,
-          "editType": "calc",
-          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "colorbar": {
-          "bgcolor": {
-            "description": "Sets the color of padded area.",
-            "dflt": "rgba(0,0,0,0)",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "bordercolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "borderwidth": {
-            "description": "Sets the width (in px) or the border enclosing this color bar.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "dtick": {
-            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "line": {
+            "autocolorscale": {
+              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "cauto": {
+              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "cmax": {
+              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "cmid": {
+              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "cmin": {
+              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "color": {
+              "arrayOk": true,
+              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "coloraxis": {
+              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+              "dflt": null,
+              "editType": "calc",
+              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+              "valType": "subplotid",
+              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "colorscale": {
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "autocolorscale": false,
+                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "colorscale",
+              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "editType": "calc",
+            "reversescale": {
+              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "role": "object",
+            "width": {
+              "arrayOk": false,
+              "description": "Sets the width (in px) of the lines bounding the marker points.",
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "editType": "colorbars",
-          "exponentformat": {
-            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-            "dflt": "B",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "none",
-              "e",
-              "E",
-              "power",
-              "SI",
-              "B",
-              "SI extended"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "labelalias": {
-            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scatter3d'))"
           },
-          "len": {
-            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-            "dflt": 1,
-            "editType": "colorbars",
+          "opacity": {
+            "arrayOk": false,
+            "description": "Sets the marker opacity. Note that the marker opacity for scatter3d traces must be a scalar value for performance reasons. To set a blending opacity value (i.e. which is not transparent), set *marker.color* to an rgba color and use its alpha channel.",
+            "editType": "calc",
+            "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "lenmode": {
-            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-            "dflt": "fraction",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "reversescale": {
+            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "minexponent": {
-            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-            "dflt": 3,
-            "editType": "colorbars",
+          "role": "object",
+          "showscale": {
+            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "size": {
+            "arrayOk": true,
+            "description": "Sets the marker size (in px).",
+            "dflt": 8,
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "nticks": {
-            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+          "sizemin": {
+            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.",
             "dflt": 0,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_sizemin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "orientation": {
-            "description": "Sets the orientation of the colorbar.",
-            "dflt": "v",
-            "editType": "colorbars",
+          "sizemode": {
+            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.",
+            "dflt": "diameter",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "h",
-              "v"
+              "diameter",
+              "area"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "outlinecolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(marker_sizemode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "outlinewidth": {
-            "description": "Sets the width (in px) of the axis line.",
+          "sizeref": {
+            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.",
             "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
+            "editType": "calc",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "role": "object",
-          "separatethousands": {
-            "description": "If \"true\", even 4-digit integers are separated",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "showexponent": {
-            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-            "dflt": "all",
-            "editType": "colorbars",
+          "symbol": {
+            "arrayOk": true,
+            "description": "Sets the marker symbol type.",
+            "dflt": "circle",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "all",
-              "first",
-              "last",
-              "none"
+              "circle",
+              "circle-open",
+              "cross",
+              "diamond",
+              "diamond-open",
+              "square",
+              "square-open",
+              "x"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "showticklabels": {
-            "description": "Determines whether or not the tick labels are drawn.",
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scatter3d'))"
+        },
+        "line": {
+          "autocolorscale": {
+            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `line.colorscale`. Has an effect only if in `line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
-            "editType": "colorbars",
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "showtickprefix": {
-            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "showticksuffix": {
-            "description": "Same as `showtickprefix` but for tick suffixes.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "cauto": {
+            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `line.color`) or the bounds set in `line.cmin` and `line.cmax` Has an effect only if in `line.color` is set to a numerical array. Defaults to `false` when `line.cmin` and `line.cmax` are set by the user.",
+            "dflt": true,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(line_cauto=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "thickness": {
-            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-            "dflt": 30,
-            "editType": "colorbars",
-            "min": 0,
+          "cmax": {
+            "description": "Sets the upper bound of the color domain. Has an effect only if in `line.color` is set to a numerical array. Value should have the same units as in `line.color` and if set, `line.cmin` must be set as well.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "thicknessmode": {
-            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-            "dflt": "pixels",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(line_cmax=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tick0": {
-            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "colorbars",
+          "cmid": {
+            "description": "Sets the mid-point of the color domain by scaling `line.cmin` and/or `line.cmax` to be equidistant to this point. Has an effect only if in `line.color` is set to a numerical array. Value should have the same units as in `line.color`. Has no effect when `line.cauto` is `false`.",
+            "dflt": null,
+            "editType": "calc",
             "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_cmid=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickangle": {
-            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-            "dflt": "auto",
-            "editType": "colorbars",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "cmin": {
+            "description": "Sets the lower bound of the color domain. Has an effect only if in `line.color` is set to a numerical array. Value should have the same units as in `line.color` and if set, `line.cmax` must be set as well.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_cmin=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickcolor": {
-            "description": "Sets the tick color.",
-            "dflt": "#444",
-            "editType": "colorbars",
+          "color": {
+            "arrayOk": true,
+            "description": "Sets the line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `line.cmin` and `line.cmax` if set.",
+            "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickfont": {
-            "color": {
-              "editType": "colorbars",
+          "coloraxis": {
+            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+            "dflt": null,
+            "editType": "calc",
+            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+            "valType": "subplotid",
+            "magic_underscores": "fig.update_traces(line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "colorbar": {
+            "bgcolor": {
+              "description": "Sets the color of padded area.",
+              "dflt": "rgba(0,0,0,0)",
+              "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "bordercolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(line_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "borderwidth": {
+              "description": "Sets the width (in px) or the border enclosing this color bar.",
+              "dflt": 0,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "dtick": {
+              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+              "editType": "calc",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(line_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(line_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "editType": "calc",
+            "exponentformat": {
+              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+              "dflt": "B",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "none",
+                "e",
+                "E",
+                "power",
+                "SI",
+                "B",
+                "SI extended"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "labelalias": {
+              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(line_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "len": {
+              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "lenmode": {
+              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+              "dflt": "fraction",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "minexponent": {
+              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+              "dflt": 3,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "nticks": {
+              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+              "dflt": 0,
+              "editType": "calc",
+              "min": 0,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(line_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "orientation": {
+              "description": "Sets the orientation of the colorbar.",
+              "dflt": "v",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "h",
+                "v"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "outlinecolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(line_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "outlinewidth": {
+              "description": "Sets the width (in px) of the axis line.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "role": "object",
+            "separatethousands": {
+              "description": "If \"true\", even 4-digit integers are separated",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(line_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showexponent": {
+              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showticklabels": {
+              "description": "Determines whether or not the tick labels are drawn.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(line_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showtickprefix": {
+              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "showticksuffix": {
+              "description": "Same as `showtickprefix` but for tick suffixes.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "thickness": {
+              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+              "dflt": 30,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "thicknessmode": {
+              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+              "dflt": "pixels",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tick0": {
+              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+              "editType": "calc",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(line_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(line_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickangle": {
+              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+              "dflt": "auto",
+              "editType": "calc",
+              "valType": "angle",
+              "magic_underscores": "fig.update_traces(line_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickcolor": {
+              "description": "Sets the tick color.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(line_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickfont": {
+              "color": {
+                "editType": "calc",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "description": "Sets the color bar's tick label font",
+              "editType": "calc",
+              "family": {
+                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                "editType": "calc",
+                "noBlank": true,
+                "strict": true,
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "lineposition": {
+                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                "dflt": "none",
+                "editType": "calc",
+                "extras": [
+                  "none"
+                ],
+                "flags": [
+                  "under",
+                  "over",
+                  "through"
+                ],
+                "valType": "flaglist",
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "role": "object",
+              "shadow": {
+                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                "dflt": "none",
+                "editType": "calc",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "size": {
+                "editType": "calc",
+                "min": 1,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "style": {
+                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                "dflt": "normal",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "italic"
+                ],
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "textcase": {
+                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                "dflt": "normal",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "calc",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(line_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "magic_underscores": "fig.update_traces(line_colorbar_tickfont=dict(...), selector=dict(type='scatter3d'))"
             },
-            "description": "Sets the color bar's tick label font",
-            "editType": "colorbars",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "colorbars",
-              "noBlank": true,
-              "strict": true,
+            "tickformat": {
+              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+              "dflt": "",
+              "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "colorbars",
-              "extras": [
-                "none"
+            "tickformatstops": {
+              "items": {
+                "tickformatstop": {
+                  "dtickrange": {
+                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                    "editType": "calc",
+                    "items": [
+                      {
+                        "editType": "calc",
+                        "valType": "any"
+                      },
+                      {
+                        "editType": "calc",
+                        "valType": "any"
+                      }
+                    ],
+                    "valType": "info_array"
+                  },
+                  "editType": "calc",
+                  "enabled": {
+                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                    "dflt": true,
+                    "editType": "calc",
+                    "valType": "boolean"
+                  },
+                  "name": {
+                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                    "editType": "calc",
+                    "valType": "string"
+                  },
+                  "role": "object",
+                  "templateitemname": {
+                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                    "editType": "calc",
+                    "valType": "string"
+                  },
+                  "value": {
+                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                    "dflt": "",
+                    "editType": "calc",
+                    "valType": "string"
+                  }
+                }
+              },
+              "role": "object",
+              "magic_underscores": "fig.update_traces(line_colorbar_tickformatstops=list(...), selector=dict(type='scatter3d'))"
+            },
+            "ticklabeloverflow": {
+              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "allow",
+                "hide past div",
+                "hide past domain"
               ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+              "magic_underscores": "fig.update_traces(line_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "ticklabelposition": {
+              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+              "dflt": "outside",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "outside",
+                "inside",
+                "outside top",
+                "inside top",
+                "outside left",
+                "inside left",
+                "outside right",
+                "inside right",
+                "outside bottom",
+                "inside bottom"
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "colorbars",
+            "ticklabelstep": {
+              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(line_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "ticklen": {
+              "description": "Sets the tick length (in px).",
+              "dflt": 5,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickmode": {
+              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(line_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "valType": "enumerated",
+              "values": [
+                "auto",
+                "linear",
+                "array"
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickprefix": {
+              "description": "Sets a tick label prefix.",
+              "dflt": "",
+              "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "size": {
-              "editType": "colorbars",
-              "min": 1,
+            "ticks": {
+              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+              "dflt": "",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "outside",
+                "inside",
+                ""
+              ],
+              "magic_underscores": "fig.update_traces(line_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "ticksuffix": {
+              "description": "Sets a tick label suffix.",
+              "dflt": "",
+              "editType": "calc",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(line_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "ticktext": {
+              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(line_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickvals": {
+              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(line_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "tickwidth": {
+              "description": "Sets the tick width (in px).",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "colorbars",
+            "title": {
+              "editType": "calc",
+              "font": {
+                "color": {
+                  "editType": "calc",
+                  "valType": "color",
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "description": "Sets this color bar's title font.",
+                "editType": "calc",
+                "family": {
+                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                  "editType": "calc",
+                  "noBlank": true,
+                  "strict": true,
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "lineposition": {
+                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                  "dflt": "none",
+                  "editType": "calc",
+                  "extras": [
+                    "none"
+                  ],
+                  "flags": [
+                    "under",
+                    "over",
+                    "through"
+                  ],
+                  "valType": "flaglist",
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "role": "object",
+                "shadow": {
+                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                  "dflt": "none",
+                  "editType": "calc",
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "size": {
+                  "editType": "calc",
+                  "min": 1,
+                  "valType": "number",
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "style": {
+                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "italic"
+                  ],
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "textcase": {
+                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "word caps",
+                    "upper",
+                    "lower"
+                  ],
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "variant": {
+                  "description": "Sets the variant of the font.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "small-caps",
+                    "all-small-caps",
+                    "all-petite-caps",
+                    "petite-caps",
+                    "unicase"
+                  ],
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "weight": {
+                  "description": "Sets the weight (or boldness) of the font.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "extras": [
+                    "normal",
+                    "bold"
+                  ],
+                  "max": 1000,
+                  "min": 1,
+                  "valType": "integer",
+                  "magic_underscores": "fig.update_traces(line_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+                },
+                "magic_underscores": "fig.update_traces(line_colorbar_title_font=dict(...), selector=dict(type='scatter3d'))"
+              },
+              "role": "object",
+              "side": {
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "right",
+                  "top",
+                  "bottom"
+                ],
+                "magic_underscores": "fig.update_traces(line_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "text": {
+                "description": "Sets the title of the color bar.",
+                "editType": "calc",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(line_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+              },
+              "magic_underscores": "fig.update_traces(line_colorbar_title=dict(...), selector=dict(type='scatter3d'))"
+            },
+            "x": {
+              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "xanchor": {
+              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "left",
+                "center",
+                "right"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "colorbars",
+            "xpad": {
+              "description": "Sets the amount of padding (in px) along the x direction.",
+              "dflt": 10,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "xref": {
+              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+              "dflt": "paper",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "container",
+                "paper"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
+            "y": {
+              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "yanchor": {
+              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "top",
+                "middle",
+                "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "extras": [
-                "normal",
-                "bold"
+            "ypad": {
+              "description": "Sets the amount of padding (in px) along the y direction.",
+              "dflt": 10,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(line_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "yref": {
+              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+              "dflt": "paper",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "container",
+                "paper"
               ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              "magic_underscores": "fig.update_traces(line_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(line_colorbar=dict(...), selector=dict(type='scatter3d'))"
+          },
+          "colorscale": {
+            "description": "Sets the colorscale. Has an effect only if in `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "autocolorscale": false,
+              "magic_underscores": "fig.update_traces(line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "valType": "colorscale",
+            "magic_underscores": "fig.update_traces(line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "dash": {
+            "description": "Sets the dash style of the lines.",
+            "dflt": "solid",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "dash",
+              "dashdot",
+              "dot",
+              "longdash",
+              "longdashdot",
+              "solid"
+            ],
+            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "editType": "calc",
+          "reversescale": {
+            "description": "Reverses the color mapping if true. Has an effect only if in `line.color` is set to a numerical array. If true, `line.cmin` will correspond to the last color in the array and `line.cmax` will correspond to the first color.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(line_reversescale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "role": "object",
+          "showscale": {
+            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `line.color` is set to a numerical array.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(line_showscale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickformat": {
-            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-            "dflt": "",
-            "editType": "colorbars",
+          "width": {
+            "description": "Sets the line width (in px).",
+            "dflt": 2,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='scatter3d'))"
+        },
+        "textfont": {
+          "color": {
+            "arrayOk": true,
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "description": "Sets the text font.",
+          "editType": "calc",
+          "family": {
+            "arrayOk": true,
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+            "editType": "calc",
+            "noBlank": true,
+            "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickformatstops": {
-            "items": {
-              "tickformatstop": {
-                "dtickrange": {
-                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "colorbars",
-                  "items": [
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    },
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "editType": "colorbars",
-                "enabled": {
-                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                  "dflt": true,
-                  "editType": "colorbars",
-                  "valType": "boolean"
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "value": {
-                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                  "dflt": "",
-                  "editType": "colorbars",
-                  "valType": "string"
-                }
-              }
-            },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='streamtube'))"
+          "role": "object",
+          "size": {
+            "arrayOk": true,
+            "editType": "calc",
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticklabeloverflow": {
-            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "colorbars",
+          "style": {
+            "arrayOk": true,
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "allow",
-              "hide past div",
-              "hide past domain"
+              "normal",
+              "italic"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticklabelposition": {
-            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-            "dflt": "outside",
-            "editType": "colorbars",
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "outside",
-              "inside",
-              "outside top",
-              "inside top",
-              "outside left",
-              "inside left",
-              "outside right",
-              "inside right",
-              "outside bottom",
-              "inside bottom"
+              "normal",
+              "small-caps"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticklabelstep": {
-            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-            "dflt": 1,
-            "editType": "colorbars",
+          "weight": {
+            "arrayOk": true,
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticklen": {
-            "description": "Sets the tick length (in px).",
-            "dflt": 5,
-            "editType": "colorbars",
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scatter3d'))"
+        },
+        "error_x": {
+          "array": {
+            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_x_array=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "arrayminus": {
+            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_x_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "color": {
+            "description": "Sets the stroke color of the error bars.",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(error_x_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "copy_zstyle": {
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_x_copy_zstyle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "editType": "calc",
+          "role": "object",
+          "symmetric": {
+            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_x_symmetric=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "thickness": {
+            "description": "Sets the thickness (in px) of the error bars.",
+            "dflt": 2,
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_x_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickmode": {
-            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "valType": "enumerated",
-            "values": [
-              "auto",
-              "linear",
-              "array"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "traceref": {
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_x_traceref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickprefix": {
-            "description": "Sets a tick label prefix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "tracerefminus": {
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_x_tracerefminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticks": {
-            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-            "dflt": "",
-            "editType": "colorbars",
+          "type": {
+            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "outside",
-              "inside",
-              ""
+              "percent",
+              "constant",
+              "sqrt",
+              "data"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_x_type=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticksuffix": {
-            "description": "Sets a tick label suffix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "value": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_x_value=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticktext": {
-            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "valueminus": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_x_valueminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
+          "visible": {
+            "description": "Determines whether or not this set of error bars is visible.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_x_visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickvals": {
-            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "colorbars",
+          "width": {
+            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_x_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "magic_underscores": "fig.update_traces(error_x=dict(...), selector=dict(type='scatter3d'))"
+        },
+        "error_y": {
+          "array": {
+            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
+            "editType": "calc",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_y_array=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+          "arrayminus": {
+            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_y_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "tickwidth": {
-            "description": "Sets the tick width (in px).",
-            "dflt": 1,
-            "editType": "colorbars",
+          "color": {
+            "description": "Sets the stroke color of the error bars.",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(error_y_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "copy_zstyle": {
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_y_copy_zstyle=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "editType": "calc",
+          "role": "object",
+          "symmetric": {
+            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_y_symmetric=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "thickness": {
+            "description": "Sets the thickness (in px) of the error bars.",
+            "dflt": 2,
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_y_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "title": {
-            "editType": "colorbars",
-            "font": {
-              "color": {
-                "editType": "colorbars",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "description": "Sets this color bar's title font.",
-              "editType": "colorbars",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "size": {
-                "editType": "colorbars",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-              },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='streamtube'))"
-            },
-            "role": "object",
-            "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "right",
-                "top",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "text": {
-              "description": "Sets the title of the color bar.",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='streamtube'))"
+          "traceref": {
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_y_traceref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "x": {
-            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "colorbars",
+          "tracerefminus": {
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_y_tracerefminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "type": {
+            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "percent",
+              "constant",
+              "sqrt",
+              "data"
+            ],
+            "magic_underscores": "fig.update_traces(error_y_type=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "value": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_y_value=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "valueminus": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_y_valueminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "visible": {
+            "description": "Determines whether or not this set of error bars is visible.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_y_visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "width": {
+            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_y_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "magic_underscores": "fig.update_traces(error_y=dict(...), selector=dict(type='scatter3d'))"
+        },
+        "error_z": {
+          "array": {
+            "description": "Sets the data corresponding the length of each error bar. Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_z_array=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "arrayminus": {
+            "description": "Sets the data corresponding the length of each error bar in the bottom (left) direction for vertical (horizontal) bars Values are plotted relative to the underlying data.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(error_z_arrayminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+          },
+          "color": {
+            "description": "Sets the stroke color of the error bars.",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(error_z_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "xanchor": {
-            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "editType": "calc",
+          "role": "object",
+          "symmetric": {
+            "description": "Determines whether or not the error bars have the same length in both direction (top/bottom for vertical bars, left/right for horizontal bars.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_z_symmetric=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "xpad": {
-            "description": "Sets the amount of padding (in px) along the x direction.",
-            "dflt": 10,
-            "editType": "colorbars",
+          "thickness": {
+            "description": "Sets the thickness (in px) of the error bars.",
+            "dflt": 2,
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_z_thickness=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "xref": {
-            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "traceref": {
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_z_traceref=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "y": {
-            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "tracerefminus": {
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(error_z_tracerefminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "yanchor": {
-            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "colorbars",
+          "type": {
+            "description": "Determines the rule used to generate the error bars. If *constant*, the bar lengths are of a constant value. Set this constant in `value`. If *percent*, the bar lengths correspond to a percentage of underlying data. Set this percentage in `value`. If *sqrt*, the bar lengths correspond to the square of the underlying data. If *data*, the bar lengths are set with data set `array`.",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "top",
-              "middle",
-              "bottom"
+              "percent",
+              "constant",
+              "sqrt",
+              "data"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_z_type=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "ypad": {
-            "description": "Sets the amount of padding (in px) along the y direction.",
+          "value": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars.",
             "dflt": 10,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(error_z_value=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "yref": {
-            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "valueminus": {
+            "description": "Sets the value of either the percentage (if `type` is set to *percent*) or the constant (if `type` is set to *constant*) corresponding to the lengths of the error bars in the bottom (left) direction for vertical (horizontal) bars",
+            "dflt": 10,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_z_valueminus=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='streamtube'))"
-        },
-        "autocolorscale": {
-          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "visible": {
+            "description": "Determines whether or not this set of error bars is visible.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(error_z_visible=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "width": {
+            "description": "Sets the width (in px) of the cross-bar at both ends of the error bars.",
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(error_z_width=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "showscale": {
-          "description": "Determines whether or not a colorbar is displayed for this trace.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
-          "dflt": false,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "magic_underscores": "fig.update_traces(error_z=dict(...), selector=dict(type='scatter3d'))"
         },
         "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
           "dflt": "",
-          "editType": "none",
+          "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
         },
-        "cauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here u/v/w norm) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
-          "dflt": true,
+        "connectgaps": {
+          "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.",
+          "dflt": false,
           "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "cmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmin` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "cmid": {
-          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as u/v/w norm. Has no effect when `cauto` is `false`.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "cmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmax` must be set as well.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "cauto": false,
-            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
         },
         "hoverlabel": {
           "align": {
@@ -60795,36 +50709,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
           "editType": "none",
           "font": {
@@ -60832,12 +50731,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -60848,12 +50742,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -60869,12 +50758,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "role": "object",
             "shadow": {
@@ -60883,24 +50767,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "style": {
               "arrayOk": true,
@@ -60912,12 +50786,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -60931,12 +50800,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "variant": {
               "arrayOk": true,
@@ -60952,12 +50816,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
             "weight": {
               "arrayOk": true,
@@ -60971,14 +50830,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scatter3d'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -60987,12 +50841,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
           "role": "object",
           "showarrow": {
@@ -61000,218 +50849,228 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='streamtube'))"
-        },
-        "lighting": {
-          "ambient": {
-            "description": "Ambient light increases overall color visibility but can wash out the image.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "diffuse": {
-            "description": "Represents the extent that incident rays are reflected in a range of angles.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "editType": "calc",
-          "facenormalsepsilon": {
-            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-06,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "fresnel": {
-            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
-            "dflt": 0.2,
-            "editType": "calc",
-            "max": 5,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "role": "object",
-          "roughness": {
-            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
-            "dflt": 0.5,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "specular": {
-            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
-            "dflt": 0.05,
-            "editType": "calc",
-            "max": 2,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "vertexnormalsepsilon": {
-            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-12,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
           },
-          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='streamtube'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='scatter3d'))"
         },
-        "lightposition": {
+        "projection": {
           "editType": "calc",
           "role": "object",
           "x": {
-            "description": "Numeric vector, representing the X coordinate for each vertex.",
-            "dflt": 100000,
             "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "opacity": {
+              "description": "Sets the projection color.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(projection_x_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "role": "object",
+            "scale": {
+              "description": "Sets the scale factor determining the size of the projection marker points.",
+              "dflt": 0.6666666666666666,
+              "editType": "calc",
+              "max": 10,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(projection_x_scale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "show": {
+              "description": "Sets whether or not projections are shown along the x axis.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(projection_x_show=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "magic_underscores": "fig.update_traces(projection_x=dict(...), selector=dict(type='scatter3d'))"
           },
           "y": {
-            "description": "Numeric vector, representing the Y coordinate for each vertex.",
-            "dflt": 100000,
             "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "opacity": {
+              "description": "Sets the projection color.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(projection_y_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "role": "object",
+            "scale": {
+              "description": "Sets the scale factor determining the size of the projection marker points.",
+              "dflt": 0.6666666666666666,
+              "editType": "calc",
+              "max": 10,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(projection_y_scale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "show": {
+              "description": "Sets whether or not projections are shown along the y axis.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(projection_y_show=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "magic_underscores": "fig.update_traces(projection_y=dict(...), selector=dict(type='scatter3d'))"
           },
           "z": {
-            "description": "Numeric vector, representing the Z coordinate for each vertex.",
-            "dflt": 0,
             "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            "opacity": {
+              "description": "Sets the projection color.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(projection_z_opacity=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "role": "object",
+            "scale": {
+              "description": "Sets the scale factor determining the size of the projection marker points.",
+              "dflt": 0.6666666666666666,
+              "editType": "calc",
+              "max": 10,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(projection_z_scale=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "show": {
+              "description": "Sets whether or not projections are shown along the z axis.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(projection_z_show=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+            },
+            "magic_underscores": "fig.update_traces(projection_z=dict(...), selector=dict(type='scatter3d'))"
           },
-          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='streamtube'))"
+          "magic_underscores": "fig.update_traces(projection=dict(...), selector=dict(type='scatter3d'))"
         },
-        "maxdisplayed": {
-          "description": "The maximum number of displayed segments in a streamtube.",
-          "dflt": 1000,
+        "surfaceaxis": {
+          "description": "If *-1*, the scatter points are not fill with a surface If *0*, *1*, *2*, the scatter points are filled with a Delaunay surface about the x, y, z respectively.",
+          "dflt": -1,
           "editType": "calc",
-          "min": 0,
-          "valType": "integer",
-          "magic_underscores": "fig.update_traces(maxdisplayed=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "valType": "enumerated",
+          "values": [
+            -1,
+            0,
+            1,
+            2
+          ],
+          "magic_underscores": "fig.update_traces(surfaceaxis=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
         },
-        "sizeref": {
-          "description": "The scaling factor for the streamtubes. The default is 1, which avoids two max divergence tubes from touching at adjacent starting positions.",
-          "dflt": 1,
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
           "editType": "calc",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(sizeref=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
         },
-        "starts": {
+        "ycalendar": {
+          "description": "Sets the calendar system to use with `y` date data.",
+          "dflt": "gregorian",
           "editType": "calc",
-          "role": "object",
-          "x": {
-            "description": "Sets the x components of the starting position of the streamtubes",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(starts_x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "xsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "y": {
-            "description": "Sets the y components of the starting position of the streamtubes",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(starts_y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "ysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "z": {
-            "description": "Sets the z components of the starting position of the streamtubes",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(starts_z=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "zsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "magic_underscores": "fig.update_traces(starts=dict(...), selector=dict(type='streamtube'))"
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
+        },
+        "zcalendar": {
+          "description": "Sets the calendar system to use with `z` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(zcalendar=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='streamtube'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scatter3d'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='streamtube'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='scatter3d'))"
       },
       "categories": [
         "gl3d",
-        "showLegend"
+        "symbols",
+        "showLegend",
+        "scatter-like"
       ],
       "meta": {
-        "description": "Use a streamtube trace to visualize flow in a vector field.  Specify a vector field using 6 1D arrays of equal length, 3 position arrays `x`, `y` and `z` and 3 vector component arrays `u`, `v`, and `w`.  By default, the tubes' starting positions will be cut from the vector field's x-z plane at its minimum y value. To specify your own starting position, use attributes `starts.x`, `starts.y` and `starts.z`. The color is encoded by the norm of (u, v, w), and the local radius by the divergence of (u, v, w)."
+        "description": "The data visualized as scatter point or lines in 3D dimension is set in `x`, `y`, `z`. Text (appearing either on the chart or on hover only) is via `text`. Bubble charts are achieved by setting `marker.size` and/or `marker.color` Projections are achieved via `projection`. Surface fills are achieved via `surfaceaxis`.",
+        "hrName": "scatter_3d"
       },
-      "type": "streamtube"
+      "type": "scatter3d"
     },
-    "volume": {
+    "surface": {
       "animatable": false,
       "attributes": {
-        "type": "volume",
+        "type": "surface",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -61223,35 +51082,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": false,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -61259,7 +51118,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -61269,7 +51128,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -61284,7 +51143,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "role": "object",
             "shadow": {
@@ -61292,13 +51151,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -61309,7 +51168,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -61322,7 +51181,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -61337,7 +51196,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -61350,9 +51209,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='surface'))"
           },
           "role": "object",
           "text": {
@@ -61360,16 +51219,16 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='surface'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "opacity": {
           "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
@@ -61378,75 +51237,45 @@
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "x": {
-          "description": "Sets the X coordinates of the vertices on X axis.",
+          "description": "Sets the x coordinates.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "y": {
-          "description": "Sets the Y coordinates of the vertices on Y axis.",
+          "description": "Sets the y coordinates.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "z": {
-          "description": "Sets the Z coordinates of the vertices on Z axis.",
+          "description": "Sets the z coordinates.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
-        "value": {
-          "description": "Sets the 4th dimension (value) of the vertices.",
-          "editType": "calc+clearAxisTypes",
+        "surfacecolor": {
+          "description": "Sets the surface color values, used for setting a color scale independent of `z`.",
+          "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(value=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "valuesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `value`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(surfacecolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets the text elements associated with the vertices. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "description": "Sets the text elements associated with each z value. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "hovertext": {
           "arrayOk": true,
@@ -61454,16 +51283,11 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -61479,12 +51303,7 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "hovertemplate": {
           "arrayOk": true,
@@ -61492,70 +51311,48 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "valuehoverformat": {
-          "description": "Sets the hover text formatting rulefor `value`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(valuehoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "scene": {
           "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
           "dflt": "scene",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "coloraxis": {
           "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -61563,7 +51360,7 @@
           "editType": "calc",
           "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "colorbar": {
           "bgcolor": {
@@ -61571,14 +51368,14 @@
             "dflt": "rgba(0,0,0,0)",
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "bordercolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "borderwidth": {
             "description": "Sets the width (in px) or the border enclosing this color bar.",
@@ -61586,17 +51383,17 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "dtick": {
             "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
             "editType": "calc",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "editType": "calc",
           "exponentformat": {
@@ -61613,14 +51410,14 @@
               "B",
               "SI extended"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "labelalias": {
             "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
             "dflt": false,
             "editType": "calc",
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "len": {
             "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
@@ -61628,7 +51425,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "lenmode": {
             "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
@@ -61639,7 +51436,7 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "minexponent": {
             "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
@@ -61647,7 +51444,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "nticks": {
             "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
@@ -61655,7 +51452,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "orientation": {
             "description": "Sets the orientation of the colorbar.",
@@ -61666,14 +51463,14 @@
               "h",
               "v"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "outlinecolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "outlinewidth": {
             "description": "Sets the width (in px) of the axis line.",
@@ -61681,7 +51478,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "role": "object",
           "separatethousands": {
@@ -61689,7 +51486,7 @@
             "dflt": false,
             "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "showexponent": {
             "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
@@ -61702,14 +51499,14 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "showticklabels": {
             "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
             "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "showtickprefix": {
             "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
@@ -61722,7 +51519,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "showticksuffix": {
             "description": "Same as `showtickprefix` but for tick suffixes.",
@@ -61735,7 +51532,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "thickness": {
             "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
@@ -61743,7 +51540,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "thicknessmode": {
             "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
@@ -61754,37 +51551,37 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tick0": {
             "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
             "editType": "calc",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickangle": {
             "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
             "dflt": "auto",
             "editType": "calc",
             "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickcolor": {
             "description": "Sets the tick color.",
             "dflt": "#444",
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickfont": {
             "color": {
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "description": "Sets the color bar's tick label font",
             "editType": "calc",
@@ -61794,7 +51591,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -61809,7 +51606,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "role": "object",
             "shadow": {
@@ -61817,13 +51614,13 @@
               "dflt": "none",
               "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "size": {
               "editType": "calc",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -61834,7 +51631,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -61847,7 +51644,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -61862,7 +51659,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -61875,16 +51672,16 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='surface'))"
           },
           "tickformat": {
             "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
             "dflt": "",
             "editType": "calc",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickformatstops": {
             "items": {
@@ -61931,7 +51728,7 @@
               }
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='surface'))"
           },
           "ticklabeloverflow": {
             "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
@@ -61942,7 +51739,7 @@
               "hide past div",
               "hide past domain"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "ticklabelposition": {
             "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
@@ -61961,7 +51758,7 @@
               "outside bottom",
               "inside bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "ticklabelstep": {
             "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
@@ -61969,7 +51766,7 @@
             "editType": "calc",
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "ticklen": {
             "description": "Sets the tick length (in px).",
@@ -61977,13 +51774,13 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickmode": {
             "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
             "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "valType": "enumerated",
             "values": [
@@ -61991,14 +51788,14 @@
               "linear",
               "array"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickprefix": {
             "description": "Sets a tick label prefix.",
             "dflt": "",
             "editType": "calc",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "ticks": {
             "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
@@ -62010,36 +51807,26 @@
               "inside",
               ""
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "ticksuffix": {
             "description": "Sets a tick label suffix.",
             "dflt": "",
             "editType": "calc",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "ticktext": {
             "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
             "editType": "calc",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "calc",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
@@ -62047,7 +51834,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "title": {
             "editType": "calc",
@@ -62055,7 +51842,7 @@
               "color": {
                 "editType": "calc",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "description": "Sets this color bar's title font.",
               "editType": "calc",
@@ -62065,7 +51852,7 @@
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -62080,7 +51867,7 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "role": "object",
               "shadow": {
@@ -62088,13 +51875,13 @@
                 "dflt": "none",
                 "editType": "calc",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "size": {
                 "editType": "calc",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -62105,7 +51892,7 @@
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -62118,7 +51905,7 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
@@ -62133,7 +51920,7 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
@@ -62146,13 +51933,13 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
               },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='surface'))"
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
@@ -62160,21 +51947,21 @@
                 "top",
                 "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "text": {
               "description": "Sets the title of the color bar.",
               "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='surface'))"
           },
           "x": {
             "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
             "editType": "calc",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "xanchor": {
             "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
@@ -62185,7 +51972,7 @@
               "center",
               "right"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "xpad": {
             "description": "Sets the amount of padding (in px) along the x direction.",
@@ -62193,7 +51980,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "xref": {
             "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
@@ -62204,13 +51991,13 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "y": {
             "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
             "editType": "calc",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "yanchor": {
             "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
@@ -62221,7 +52008,7 @@
               "middle",
               "bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "ypad": {
             "description": "Sets the amount of padding (in px) along the y direction.",
@@ -62229,7 +52016,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "yref": {
             "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
@@ -62240,196 +52027,430 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='surface'))"
         },
         "autocolorscale": {
           "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": true,
+          "dflt": false,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "showscale": {
           "description": "Determines whether or not a colorbar is displayed for this trace.",
           "dflt": true,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "reversescale": {
           "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
           "dflt": false,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "cauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here `value`) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here z or surfacecolor) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "cmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as `value` and if set, `cmin` must be set as well.",
+          "description": "Sets the upper bound of the color domain. Value should have the same units as z or surfacecolor and if set, `cmin` must be set as well.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "cauto": false,
-            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "cmid": {
-          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as `value`. Has no effect when `cauto` is `false`.",
+          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as z or surfacecolor. Has no effect when `cauto` is `false`.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "cmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as `value` and if set, `cmax` must be set as well.",
+          "description": "Sets the lower bound of the color domain. Value should have the same units as z or surfacecolor and if set, `cmax` must be set as well.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "cauto": false,
-            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
-        "caps": {
+        "connectgaps": {
+          "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the `z` data are filled in.",
+          "dflt": false,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        },
+        "contours": {
           "editType": "calc",
           "role": "object",
           "x": {
+            "color": {
+              "description": "Sets the color of the contour lines.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(contours_x_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
             "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
+            "end": {
+              "description": "Sets the end contour level value. Must be more than `contours.start`",
+              "dflt": null,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_x_end=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlight": {
+              "description": "Determines whether or not contour lines about the x dimension are highlighted on hover.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(contours_x_highlight=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlightcolor": {
+              "description": "Sets the color of the highlighted contour lines.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(contours_x_highlightcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlightwidth": {
+              "description": "Sets the width of the highlighted contour lines.",
+              "dflt": 2,
+              "editType": "calc",
+              "max": 16,
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_x_highlightwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "project": {
+              "editType": "calc",
+              "role": "object",
+              "x": {
+                "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_x_project_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "y": {
+                "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_x_project_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "z": {
+                "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_x_project_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "magic_underscores": "fig.update_traces(contours_x_project=dict(...), selector=dict(type='surface'))"
+            },
+            "role": "object",
+            "show": {
+              "description": "Determines whether or not contour lines about the x dimension are drawn.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(contours_x_show=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "size": {
+              "description": "Sets the step between each contour level. Must be positive.",
+              "dflt": null,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_x_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "start": {
+              "description": "Sets the starting contour level value. Must be less than `contours.end`",
+              "dflt": null,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_x_start=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "usecolormap": {
+              "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(contours_x_usecolormap=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "width": {
+              "description": "Sets the width of the contour lines.",
+              "dflt": 2,
+              "editType": "calc",
+              "max": 16,
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_x_width=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "magic_underscores": "fig.update_traces(contours_x=dict(...), selector=dict(type='surface'))"
+          },
+          "y": {
+            "color": {
+              "description": "Sets the color of the contour lines.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(contours_y_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "editType": "calc",
+            "end": {
+              "description": "Sets the end contour level value. Must be more than `contours.start`",
+              "dflt": null,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_y_end=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlight": {
+              "description": "Determines whether or not contour lines about the y dimension are highlighted on hover.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(contours_y_highlight=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlightcolor": {
+              "description": "Sets the color of the highlighted contour lines.",
+              "dflt": "#444",
               "editType": "calc",
-              "max": 1,
-              "min": 0,
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(contours_y_highlightcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlightwidth": {
+              "description": "Sets the width of the highlighted contour lines.",
+              "dflt": 2,
+              "editType": "calc",
+              "max": 16,
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(caps_x_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(contours_y_highlightwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "project": {
+              "editType": "calc",
+              "role": "object",
+              "x": {
+                "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_y_project_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "y": {
+                "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_y_project_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "z": {
+                "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_y_project_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "magic_underscores": "fig.update_traces(contours_y_project=dict(...), selector=dict(type='surface'))"
             },
             "role": "object",
             "show": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the x `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": true,
+              "description": "Determines whether or not contour lines about the y dimension are drawn.",
+              "dflt": false,
               "editType": "calc",
               "valType": "boolean",
-              "magic_underscores": "fig.update_traces(caps_x_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(contours_y_show=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "magic_underscores": "fig.update_traces(caps_x=dict(...), selector=dict(type='volume'))"
-          },
-          "y": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
+            "size": {
+              "description": "Sets the step between each contour level. Must be positive.",
+              "dflt": null,
               "editType": "calc",
-              "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(caps_y_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(contours_y_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "role": "object",
-            "show": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the y `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": true,
+            "start": {
+              "description": "Sets the starting contour level value. Must be less than `contours.end`",
+              "dflt": null,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_y_start=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "usecolormap": {
+              "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.",
+              "dflt": false,
               "editType": "calc",
               "valType": "boolean",
-              "magic_underscores": "fig.update_traces(caps_y_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(contours_y_usecolormap=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "magic_underscores": "fig.update_traces(caps_y=dict(...), selector=dict(type='volume'))"
+            "width": {
+              "description": "Sets the width of the contour lines.",
+              "dflt": 2,
+              "editType": "calc",
+              "max": 16,
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_y_width=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "magic_underscores": "fig.update_traces(contours_y=dict(...), selector=dict(type='surface'))"
           },
           "z": {
+            "color": {
+              "description": "Sets the color of the contour lines.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(contours_z_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
             "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
+            "end": {
+              "description": "Sets the end contour level value. Must be more than `contours.start`",
+              "dflt": null,
               "editType": "calc",
-              "max": 1,
-              "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(caps_z_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(contours_z_end=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlight": {
+              "description": "Determines whether or not contour lines about the z dimension are highlighted on hover.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(contours_z_highlight=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlightcolor": {
+              "description": "Sets the color of the highlighted contour lines.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(contours_z_highlightcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "highlightwidth": {
+              "description": "Sets the width of the highlighted contour lines.",
+              "dflt": 2,
+              "editType": "calc",
+              "max": 16,
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_z_highlightwidth=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "project": {
+              "editType": "calc",
+              "role": "object",
+              "x": {
+                "description": "Determines whether or not these contour lines are projected on the x plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_z_project_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "y": {
+                "description": "Determines whether or not these contour lines are projected on the y plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_z_project_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "z": {
+                "description": "Determines whether or not these contour lines are projected on the z plane. If `highlight` is set to *true* (the default), the projected lines are shown on hover. If `show` is set to *true*, the projected lines are shown in permanence.",
+                "dflt": false,
+                "editType": "calc",
+                "valType": "boolean",
+                "magic_underscores": "fig.update_traces(contours_z_project_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
+              },
+              "magic_underscores": "fig.update_traces(contours_z_project=dict(...), selector=dict(type='surface'))"
             },
             "role": "object",
             "show": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the z `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": true,
+              "description": "Determines whether or not contour lines about the z dimension are drawn.",
+              "dflt": false,
               "editType": "calc",
               "valType": "boolean",
-              "magic_underscores": "fig.update_traces(caps_z_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+              "magic_underscores": "fig.update_traces(contours_z_show=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "magic_underscores": "fig.update_traces(caps_z=dict(...), selector=dict(type='volume'))"
-          },
-          "magic_underscores": "fig.update_traces(caps=dict(...), selector=dict(type='volume'))"
-        },
-        "contour": {
-          "color": {
-            "description": "Sets the color of the contour lines.",
-            "dflt": "#444",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(contour_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "editType": "calc",
-          "role": "object",
-          "show": {
-            "description": "Sets whether or not dynamic contours are shown on hover",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(contour_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "width": {
-            "description": "Sets the width of the contour lines.",
-            "dflt": 2,
-            "editType": "calc",
-            "max": 16,
-            "min": 1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(contour_width=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "size": {
+              "description": "Sets the step between each contour level. Must be positive.",
+              "dflt": null,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_z_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "start": {
+              "description": "Sets the starting contour level value. Must be less than `contours.end`",
+              "dflt": null,
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_z_start=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "usecolormap": {
+              "description": "An alternate to *color*. Determines whether or not the contour lines are colored using the trace *colorscale*.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(contours_z_usecolormap=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "width": {
+              "description": "Sets the width of the contour lines.",
+              "dflt": 2,
+              "editType": "calc",
+              "max": 16,
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(contours_z_width=&lt;VALUE&gt;, selector=dict(type='surface'))"
+            },
+            "magic_underscores": "fig.update_traces(contours_z=dict(...), selector=dict(type='surface'))"
           },
-          "magic_underscores": "fig.update_traces(contour=dict(...), selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(contours=dict(...), selector=dict(type='surface'))"
         },
-        "flatshading": {
-          "description": "Determines whether or not normal smoothing is applied to the meshes, creating meshes with an angular, low-poly look via flat reflections.",
-          "dflt": true,
+        "hidesurface": {
+          "description": "Determines whether or not a surface is drawn. For example, set `hidesurface` to *false* `contours.x.show` to *true* and `contours.y.show` to *true* to draw a wire frame plot.",
+          "dflt": false,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(flatshading=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(hidesurface=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "hoverlabel": {
           "align": {
@@ -62443,36 +52464,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "editType": "none",
           "font": {
@@ -62480,12 +52486,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -62496,12 +52497,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -62517,12 +52513,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "role": "object",
             "shadow": {
@@ -62531,24 +52522,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "style": {
               "arrayOk": true,
@@ -62560,12 +52541,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -62579,12 +52555,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "variant": {
               "arrayOk": true,
@@ -62600,12 +52571,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
             "weight": {
               "arrayOk": true,
@@ -62619,14 +52585,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='surface'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='surface'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -62635,12 +52596,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "role": "object",
           "showarrow": {
@@ -62648,21 +52604,9 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='volume'))"
-        },
-        "isomax": {
-          "description": "Sets the maximum boundary for iso-surface plot.",
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(isomax=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "isomin": {
-          "description": "Sets the minimum boundary for iso-surface plot.",
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(isomin=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='surface'))"
         },
         "lighting": {
           "ambient": {
@@ -62672,7 +52616,7 @@
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "diffuse": {
             "description": "Represents the extent that incident rays are reflected in a range of angles.",
@@ -62681,18 +52625,9 @@
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "editType": "calc",
-          "facenormalsepsilon": {
-            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 0,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
           "fresnel": {
             "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
             "dflt": 0.2,
@@ -62700,7 +52635,7 @@
             "max": 5,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "role": "object",
           "roughness": {
@@ -62710,7 +52645,7 @@
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "specular": {
             "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
@@ -62719,284 +52654,156 @@
             "max": 2,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "vertexnormalsepsilon": {
-            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-12,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
-          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='surface'))"
         },
         "lightposition": {
           "editType": "calc",
           "role": "object",
           "x": {
             "description": "Numeric vector, representing the X coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "y": {
-            "description": "Numeric vector, representing the Y coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "z": {
-            "description": "Numeric vector, representing the Z coordinate for each vertex.",
-            "dflt": 0,
+            "dflt": 10,
             "editType": "calc",
             "max": 100000,
             "min": -100000,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='volume'))"
-        },
-        "opacityscale": {
-          "description": "Sets the opacityscale. The opacityscale must be an array containing arrays mapping a normalized value to an opacity value. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 1], [0.5, 0.2], [1, 1]]` means that higher/lower values would have higher opacity values and those in the middle would be more transparent Alternatively, `opacityscale` may be a palette name string of the following list: 'min', 'max', 'extremes' and 'uniform'. The default is 'uniform'.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(opacityscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "slices": {
-          "editType": "calc",
-          "role": "object",
-          "x": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(slices_x_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "locations": {
-              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis x except start and end.",
-              "dflt": [],
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(slices_x_locations=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "locationssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not slice planes about the x dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(slices_x_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "magic_underscores": "fig.update_traces(slices_x=dict(...), selector=dict(type='volume'))"
+            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
           "y": {
+            "description": "Numeric vector, representing the Y coordinate for each vertex.",
+            "dflt": 10000,
             "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(slices_y_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "locations": {
-              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis y except start and end.",
-              "dflt": [],
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(slices_y_locations=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "locationssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not slice planes about the y dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(slices_y_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "magic_underscores": "fig.update_traces(slices_y=dict(...), selector=dict(type='volume'))"
-          },
-          "z": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(slices_z_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "locations": {
-              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis z except start and end.",
-              "dflt": [],
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(slices_z_locations=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "locationssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not slice planes about the z dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(slices_z_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
-            },
-            "magic_underscores": "fig.update_traces(slices_z=dict(...), selector=dict(type='volume'))"
-          },
-          "magic_underscores": "fig.update_traces(slices=dict(...), selector=dict(type='volume'))"
-        },
-        "spaceframe": {
-          "editType": "calc",
-          "fill": {
-            "description": "Sets the fill ratio of the `spaceframe` elements. The default fill value is 1 meaning that they are entirely shaded. Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-            "dflt": 1,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(spaceframe_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "role": "object",
-          "show": {
-            "description": "Displays/hides tetrahedron shapes between minimum and maximum iso-values. Often useful when either caps or surfaces are disabled or filled with values less than 1.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(spaceframe_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "magic_underscores": "fig.update_traces(spaceframe=dict(...), selector=dict(type='volume'))"
-        },
-        "surface": {
-          "count": {
-            "description": "Sets the number of iso-surfaces between minimum and maximum iso-values. By default this value is 2 meaning that only minimum and maximum surfaces would be drawn.",
-            "dflt": 2,
-            "editType": "calc",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(surface_count=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "editType": "calc",
-          "fill": {
-            "description": "Sets the fill ratio of the iso-surface. The default fill value of the surface is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-            "dflt": 1,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(surface_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "pattern": {
-            "description": "Sets the surface pattern of the iso-surface 3-D sections. The default pattern of the surface is `all` meaning that the rest of surface elements would be shaded. The check options (either 1 or 2) could be used to draw half of the squares on the surface. Using various combinations of capital `A`, `B`, `C`, `D` and `E` may also be used to reduce the number of triangles on the iso-surfaces and creating other patterns of interest.",
-            "dflt": "all",
-            "editType": "calc",
-            "extras": [
-              "all",
-              "odd",
-              "even"
-            ],
-            "flags": [
-              "A",
-              "B",
-              "C",
-              "D",
-              "E"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(surface_pattern=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
-          "role": "object",
-          "show": {
-            "description": "Hides/displays surfaces between minimum and maximum iso-values.",
-            "dflt": true,
+          "z": {
+            "description": "Numeric vector, representing the Z coordinate for each vertex.",
+            "dflt": 0,
             "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(surface_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='surface'))"
           },
-          "magic_underscores": "fig.update_traces(surface=dict(...), selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='surface'))"
+        },
+        "opacityscale": {
+          "description": "Sets the opacityscale. The opacityscale must be an array containing arrays mapping a normalized value to an opacity value. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 1], [0.5, 0.2], [1, 1]]` means that higher/lower values would have higher opacity values and those in the middle would be more transparent Alternatively, `opacityscale` may be a palette name string of the following list: 'min', 'max', 'extremes' and 'uniform'. The default is 'uniform'.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(opacityscale=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        },
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        },
+        "ycalendar": {
+          "description": "Sets the calendar system to use with `y` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='surface'))"
+        },
+        "zcalendar": {
+          "description": "Sets the calendar system to use with `z` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(zcalendar=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='volume'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='volume'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='volume'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='surface'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='volume'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='surface'))"
       },
       "categories": [
         "gl3d",
+        "2dMap",
         "showLegend"
       ],
       "meta": {
-        "description": "Draws volume trace between iso-min and iso-max values with coordinates given by four 1-dimensional arrays containing the `value`, `x`, `y` and `z` of every vertex of a uniform or non-uniform 3-D grid. Horizontal or vertical slices, caps as well as spaceframe between iso-min and iso-max values could also be drawn using this trace."
+        "description": "The data the describes the coordinates of the surface is set in `z`. Data in `z` should be a {2D array}. Coordinates in `x` and `y` can either be 1D {arrays} or {2D arrays} (e.g. to graph parametric surfaces). If not provided in `x` and `y`, the x and y coordinates are assumed to be linear starting at 0 with a unit step. The color scale corresponds to the `z` values by default. For custom color scales, use `surfacecolor` which should be a {2D array}, where its bounds can be controlled using `cmin` and `cmax`."
       },
-      "type": "volume"
+      "type": "surface"
     },
-    "isosurface": {
+    "mesh3d": {
       "animatable": false,
       "attributes": {
-        "type": "isosurface",
+        "type": "mesh3d",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -63008,35 +52815,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": false,
-          "editType": "calc",
+          "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -63044,7 +52851,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -63054,7 +52861,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -63069,7 +52876,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "role": "object",
             "shadow": {
@@ -63077,13 +52884,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -63094,7 +52901,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -63107,7 +52914,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -63122,7 +52929,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -63135,9 +52942,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='mesh3d'))"
           },
           "role": "object",
           "text": {
@@ -63145,16 +52952,16 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='mesh3d'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "opacity": {
           "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
@@ -63163,62 +52970,78 @@
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "x": {
-          "description": "Sets the X coordinates of the vertices on X axis.",
+          "description": "Sets the X coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "y": {
-          "description": "Sets the Y coordinates of the vertices on Y axis.",
+          "description": "Sets the Y coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "z": {
-          "description": "Sets the Z coordinates of the vertices on Z axis.",
+          "description": "Sets the Z coordinates of the vertices. The nth element of vectors `x`, `y` and `z` jointly represent the X, Y and Z coordinates of the nth vertex.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
+        "i": {
+          "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *first* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `i[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `i` represents a point in space, which is the first vertex of a triangle.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(i=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
-        "value": {
-          "description": "Sets the 4th dimension (value) of the vertices.",
-          "editType": "calc+clearAxisTypes",
+        "j": {
+          "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *second* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `j[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `j` represents a point in space, which is the second vertex of a triangle.",
+          "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(value=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(j=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
-        "valuesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `value`.",
-          "editType": "none",
-          "valType": "string"
+        "k": {
+          "description": "A vector of vertex indices, i.e. integer values between 0 and the length of the vertex vectors, representing the *third* vertex of a triangle. For example, `{i[m], j[m], k[m]}` together represent face m (triangle m) in the mesh, where `k[m] = n` points to the triplet `{x[n], y[n], z[n]}` in the vertex arrays. Therefore, each element in `k` represents a point in space, which is the third vertex of a triangle.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(k=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "facecolor": {
+          "description": "Sets the color of each face Overrides *color* and *vertexcolor*.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(facecolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "intensity": {
+          "description": "Sets the intensity values for vertices or cells as defined by `intensitymode`. It can be used for plotting fields on meshes.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(intensity=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "intensitymode": {
+          "description": "Determines the source of `intensity` values.",
+          "dflt": "vertex",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "vertex",
+            "cell"
+          ],
+          "magic_underscores": "fig.update_traces(intensitymode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "vertexcolor": {
+          "description": "Sets the color of each vertex Overrides *color*. While Red, green and blue colors are in the range of 0 and 255; in the case of having vertex color data in RGBA format, the alpha color should be normalized to be between 0 and 1.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(vertexcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "text": {
           "arrayOk": true,
@@ -63226,12 +53049,7 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "hovertext": {
           "arrayOk": true,
@@ -63239,16 +53057,11 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -63264,12 +53077,7 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "hovertemplate": {
           "arrayOk": true,
@@ -63277,70 +53085,48 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "valuehoverformat": {
-          "description": "Sets the hover text formatting rulefor `value`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(valuehoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "scene": {
           "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
           "dflt": "scene",
           "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "coloraxis": {
           "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -63348,46 +53134,52 @@
           "editType": "calc",
           "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "color": {
+          "description": "Sets the color of the whole mesh",
+          "editType": "calc",
+          "valType": "color",
+          "magic_underscores": "fig.update_traces(color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "colorbar": {
           "bgcolor": {
             "description": "Sets the color of padded area.",
             "dflt": "rgba(0,0,0,0)",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "bordercolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "borderwidth": {
             "description": "Sets the width (in px) or the border enclosing this color bar.",
             "dflt": 0,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "dtick": {
             "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "calc",
+            "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "editType": "calc",
+          "editType": "colorbars",
           "exponentformat": {
             "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
             "dflt": "B",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "none",
@@ -63398,88 +53190,88 @@
               "B",
               "SI extended"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "labelalias": {
             "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
             "dflt": false,
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "len": {
             "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
             "dflt": 1,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "lenmode": {
             "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
             "dflt": "fraction",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "minexponent": {
             "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
             "dflt": 3,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "nticks": {
             "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
             "dflt": 0,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "orientation": {
             "description": "Sets the orientation of the colorbar.",
             "dflt": "v",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "h",
               "v"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "outlinecolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "outlinewidth": {
             "description": "Sets the width (in px) of the axis line.",
             "dflt": 1,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "role": "object",
           "separatethousands": {
             "description": "If \"true\", even 4-digit integers are separated",
             "dflt": false,
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "showexponent": {
             "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
             "dflt": "all",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "all",
@@ -63487,19 +53279,19 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "showticklabels": {
             "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "showtickprefix": {
             "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
             "dflt": "all",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "all",
@@ -63507,12 +53299,12 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "showticksuffix": {
             "description": "Same as `showtickprefix` but for tick suffixes.",
             "dflt": "all",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "all",
@@ -63520,71 +53312,71 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "thickness": {
             "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
             "dflt": 30,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "thicknessmode": {
             "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
             "dflt": "pixels",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tick0": {
             "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "calc",
+            "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickangle": {
             "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
             "dflt": "auto",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickcolor": {
             "description": "Sets the tick color.",
             "dflt": "#444",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickfont": {
             "color": {
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "description": "Sets the color bar's tick label font",
-            "editType": "calc",
+            "editType": "colorbars",
             "family": {
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "calc",
+              "editType": "colorbars",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "calc",
+              "editType": "colorbars",
               "extras": [
                 "none"
               ],
@@ -63594,37 +53386,37 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "role": "object",
             "shadow": {
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "size": {
-              "editType": "calc",
+              "editType": "colorbars",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -63632,12 +53424,12 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -63647,12 +53439,12 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "calc",
+              "editType": "colorbars",
               "extras": [
                 "normal",
                 "bold"
@@ -63660,79 +53452,79 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='mesh3d'))"
           },
           "tickformat": {
             "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
             "dflt": "",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickformatstops": {
             "items": {
               "tickformatstop": {
                 "dtickrange": {
                   "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "items": [
                     {
-                      "editType": "calc",
+                      "editType": "colorbars",
                       "valType": "any"
                     },
                     {
-                      "editType": "calc",
+                      "editType": "colorbars",
                       "valType": "any"
                     }
                   ],
                   "valType": "info_array"
                 },
-                "editType": "calc",
+                "editType": "colorbars",
                 "enabled": {
                   "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
                   "dflt": true,
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "boolean"
                 },
                 "name": {
                   "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "string"
                 },
                 "role": "object",
                 "templateitemname": {
                   "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "string"
                 },
                 "value": {
                   "description": "string - dtickformat for described zoom level, the same as *tickformat*",
                   "dflt": "",
-                  "editType": "calc",
+                  "editType": "colorbars",
                   "valType": "string"
                 }
               }
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='mesh3d'))"
           },
           "ticklabeloverflow": {
             "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "allow",
               "hide past div",
               "hide past domain"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "ticklabelposition": {
             "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
             "dflt": "outside",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "outside",
@@ -63746,29 +53538,29 @@
               "outside bottom",
               "inside bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "ticklabelstep": {
             "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
             "dflt": 1,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "ticklen": {
             "description": "Sets the tick length (in px).",
             "dflt": 5,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickmode": {
             "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "calc",
+            "editType": "colorbars",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "valType": "enumerated",
             "values": [
@@ -63776,86 +53568,76 @@
               "linear",
               "array"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickprefix": {
             "description": "Sets a tick label prefix.",
             "dflt": "",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "ticks": {
             "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
             "dflt": "",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "outside",
               "inside",
               ""
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "ticksuffix": {
             "description": "Sets a tick label suffix.",
             "dflt": "",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "ticktext": {
             "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "calc",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "title": {
-            "editType": "calc",
+            "editType": "colorbars",
             "font": {
               "color": {
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "description": "Sets this color bar's title font.",
-              "editType": "calc",
+              "editType": "colorbars",
               "family": {
                 "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "calc",
+                "editType": "colorbars",
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
                 "dflt": "none",
-                "editType": "calc",
+                "editType": "colorbars",
                 "extras": [
                   "none"
                 ],
@@ -63865,37 +53647,37 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "role": "object",
               "shadow": {
                 "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
                 "dflt": "none",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "size": {
-                "editType": "calc",
+                "editType": "colorbars",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -63903,12 +53685,12 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -63918,12 +53700,12 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "extras": [
                   "normal",
                   "bold"
@@ -63931,255 +53713,206 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
               },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='mesh3d'))"
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "calc",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
                 "right",
                 "top",
                 "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "text": {
               "description": "Sets the title of the color bar.",
-              "editType": "calc",
+              "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='mesh3d'))"
           },
           "x": {
             "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "xanchor": {
             "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "left",
               "center",
               "right"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "xpad": {
             "description": "Sets the amount of padding (in px) along the x direction.",
             "dflt": 10,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "xref": {
             "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
             "dflt": "paper",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "y": {
             "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "yanchor": {
             "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "top",
               "middle",
               "bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "ypad": {
             "description": "Sets the amount of padding (in px) along the y direction.",
             "dflt": 10,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "yref": {
             "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
             "dflt": "paper",
-            "editType": "calc",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='mesh3d'))"
         },
         "autocolorscale": {
           "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "showscale": {
           "description": "Determines whether or not a colorbar is displayed for this trace.",
           "dflt": true,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "reversescale": {
           "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
           "dflt": false,
-          "editType": "calc",
+          "editType": "plot",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "zhoverformat": {
-          "description": "Sets the hover text formatting rulefor `z`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
           "dflt": "",
-          "editType": "calc",
+          "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "cauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here `value`) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here `intensity`) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "cmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as `value` and if set, `cmin` must be set as well.",
+          "description": "Sets the upper bound of the color domain. Value should have the same units as `intensity` and if set, `cmin` must be set as well.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "cauto": false,
-            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "cmid": {
-          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as `value`. Has no effect when `cauto` is `false`.",
+          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as `intensity`. Has no effect when `cauto` is `false`.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "cmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as `value` and if set, `cmax` must be set as well.",
+          "description": "Sets the lower bound of the color domain. Value should have the same units as `intensity` and if set, `cmax` must be set as well.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "cauto": false,
-            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
-        "caps": {
+        "alphahull": {
+          "description": "Determines how the mesh surface triangles are derived from the set of vertices (points) represented by the `x`, `y` and `z` arrays, if the `i`, `j`, `k` arrays are not supplied. For general use of `mesh3d` it is preferred that `i`, `j`, `k` are supplied. If *-1*, Delaunay triangulation is used, which is mainly suitable if the mesh is a single, more or less layer surface that is perpendicular to `delaunayaxis`. In case the `delaunayaxis` intersects the mesh surface at more than one point it will result triangles that are very long in the dimension of `delaunayaxis`. If *>0*, the alpha-shape algorithm is used. In this case, the positive `alphahull` value signals the use of the alpha-shape algorithm, _and_ its value acts as the parameter for the mesh fitting. If *0*,  the convex-hull algorithm is used. It is suitable for convex bodies or if the intention is to enclose the `x`, `y` and `z` point set into a convex hull.",
+          "dflt": -1,
           "editType": "calc",
-          "role": "object",
-          "x": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(caps_x_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "role": "object",
-            "show": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the x `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(caps_x_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "magic_underscores": "fig.update_traces(caps_x=dict(...), selector=dict(type='isosurface'))"
-          },
-          "y": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(caps_y_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "role": "object",
-            "show": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the y `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(caps_y_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "magic_underscores": "fig.update_traces(caps_y=dict(...), selector=dict(type='isosurface'))"
-          },
-          "z": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(caps_z_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "role": "object",
-            "show": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the z `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(caps_z_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "magic_underscores": "fig.update_traces(caps_z=dict(...), selector=dict(type='isosurface'))"
-          },
-          "magic_underscores": "fig.update_traces(caps=dict(...), selector=dict(type='isosurface'))"
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(alphahull=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "delaunayaxis": {
+          "description": "Sets the Delaunay axis, which is the axis that is perpendicular to the surface of the Delaunay triangulation. It has an effect if `i`, `j`, `k` are not provided and `alphahull` is set to indicate Delaunay triangulation.",
+          "dflt": "z",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "x",
+            "y",
+            "z"
+          ],
+          "magic_underscores": "fig.update_traces(delaunayaxis=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "contour": {
           "color": {
@@ -64187,7 +53920,7 @@
             "dflt": "#444",
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(contour_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(contour_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "editType": "calc",
           "role": "object",
@@ -64196,7 +53929,7 @@
             "dflt": false,
             "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(contour_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(contour_show=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "width": {
             "description": "Sets the width of the contour lines.",
@@ -64205,16 +53938,16 @@
             "max": 16,
             "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(contour_width=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(contour_width=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "magic_underscores": "fig.update_traces(contour=dict(...), selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(contour=dict(...), selector=dict(type='mesh3d'))"
         },
         "flatshading": {
           "description": "Determines whether or not normal smoothing is applied to the meshes, creating meshes with an angular, low-poly look via flat reflections.",
-          "dflt": true,
+          "dflt": false,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(flatshading=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(flatshading=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
         },
         "hoverlabel": {
           "align": {
@@ -64228,36 +53961,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "editType": "none",
           "font": {
@@ -64265,12 +53983,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -64281,12 +53994,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -64302,12 +54010,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "role": "object",
             "shadow": {
@@ -64316,24 +54019,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "style": {
               "arrayOk": true,
@@ -64345,12 +54038,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -64364,12 +54052,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "variant": {
               "arrayOk": true,
@@ -64385,12 +54068,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
             "weight": {
               "arrayOk": true,
@@ -64404,14 +54082,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='mesh3d'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -64420,362 +54093,225 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
             "dflt": true,
-            "editType": "none",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='isosurface'))"
-        },
-        "isomax": {
-          "description": "Sets the maximum boundary for iso-surface plot.",
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(isomax=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "isomin": {
-          "description": "Sets the minimum boundary for iso-surface plot.",
-          "editType": "calc",
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(isomin=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "lighting": {
-          "ambient": {
-            "description": "Ambient light increases overall color visibility but can wash out the image.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "diffuse": {
-            "description": "Represents the extent that incident rays are reflected in a range of angles.",
-            "dflt": 0.8,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "editType": "calc",
-          "facenormalsepsilon": {
-            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 0,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "fresnel": {
-            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
-            "dflt": 0.2,
-            "editType": "calc",
-            "max": 5,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "role": "object",
-          "roughness": {
-            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
-            "dflt": 0.5,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "specular": {
-            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
-            "dflt": 0.05,
-            "editType": "calc",
-            "max": 2,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "vertexnormalsepsilon": {
-            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
-            "dflt": 1e-12,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='isosurface'))"
-        },
-        "lightposition": {
-          "editType": "calc",
-          "role": "object",
-          "x": {
-            "description": "Numeric vector, representing the X coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "y": {
-            "description": "Numeric vector, representing the Y coordinate for each vertex.",
-            "dflt": 100000,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "z": {
-            "description": "Numeric vector, representing the Z coordinate for each vertex.",
-            "dflt": 0,
-            "editType": "calc",
-            "max": 100000,
-            "min": -100000,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='isosurface'))"
-        },
-        "slices": {
-          "editType": "calc",
-          "role": "object",
-          "x": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(slices_x_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "locations": {
-              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis x except start and end.",
-              "dflt": [],
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(slices_x_locations=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "locationssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not slice planes about the x dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(slices_x_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "magic_underscores": "fig.update_traces(slices_x=dict(...), selector=dict(type='isosurface'))"
-          },
-          "y": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(slices_y_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "locations": {
-              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis y except start and end.",
-              "dflt": [],
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(slices_y_locations=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "locationssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not slice planes about the y dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(slices_y_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "magic_underscores": "fig.update_traces(slices_y=dict(...), selector=dict(type='isosurface'))"
-          },
-          "z": {
-            "editType": "calc",
-            "fill": {
-              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-              "dflt": 1,
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(slices_z_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "locations": {
-              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis z except start and end.",
-              "dflt": [],
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(slices_z_locations=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "locationssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "role": "object",
-            "show": {
-              "description": "Determines whether or not slice planes about the z dimension are drawn.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(slices_z_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-            },
-            "magic_underscores": "fig.update_traces(slices_z=dict(...), selector=dict(type='isosurface'))"
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "magic_underscores": "fig.update_traces(slices=dict(...), selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='mesh3d'))"
         },
-        "spaceframe": {
-          "editType": "calc",
-          "fill": {
-            "description": "Sets the fill ratio of the `spaceframe` elements. The default fill value is 0.15 meaning that only 15% of the area of every faces of tetras would be shaded. Applying a greater `fill` ratio would allow the creation of stronger elements or could be sued to have entirely closed areas (in case of using 1).",
-            "dflt": 0.15,
+        "lighting": {
+          "ambient": {
+            "description": "Ambient light increases overall color visibility but can wash out the image.",
+            "dflt": 0.8,
             "editType": "calc",
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(spaceframe_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-          },
-          "role": "object",
-          "show": {
-            "description": "Displays/hides tetrahedron shapes between minimum and maximum iso-values. Often useful when either caps or surfaces are disabled or filled with values less than 1.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(spaceframe_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "magic_underscores": "fig.update_traces(spaceframe=dict(...), selector=dict(type='isosurface'))"
-        },
-        "surface": {
-          "count": {
-            "description": "Sets the number of iso-surfaces between minimum and maximum iso-values. By default this value is 2 meaning that only minimum and maximum surfaces would be drawn.",
-            "dflt": 2,
+          "diffuse": {
+            "description": "Represents the extent that incident rays are reflected in a range of angles.",
+            "dflt": 0.8,
             "editType": "calc",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(surface_count=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "editType": "calc",
-          "fill": {
-            "description": "Sets the fill ratio of the iso-surface. The default fill value of the surface is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
-            "dflt": 1,
+          "facenormalsepsilon": {
+            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-06,
             "editType": "calc",
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(surface_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "pattern": {
-            "description": "Sets the surface pattern of the iso-surface 3-D sections. The default pattern of the surface is `all` meaning that the rest of surface elements would be shaded. The check options (either 1 or 2) could be used to draw half of the squares on the surface. Using various combinations of capital `A`, `B`, `C`, `D` and `E` may also be used to reduce the number of triangles on the iso-surfaces and creating other patterns of interest.",
-            "dflt": "all",
+          "fresnel": {
+            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
+            "dflt": 0.2,
             "editType": "calc",
-            "extras": [
-              "all",
-              "odd",
-              "even"
-            ],
-            "flags": [
-              "A",
-              "B",
-              "C",
-              "D",
-              "E"
-            ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(surface_pattern=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "max": 5,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
           "role": "object",
-          "show": {
-            "description": "Hides/displays surfaces between minimum and maximum iso-values.",
-            "dflt": true,
+          "roughness": {
+            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
+            "dflt": 0.5,
             "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(surface_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "magic_underscores": "fig.update_traces(surface=dict(...), selector=dict(type='isosurface'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
+          "specular": {
+            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
+            "dflt": 0.05,
             "editType": "calc",
-            "max": 10000,
+            "max": 2,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          },
+          "vertexnormalsepsilon": {
+            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-12,
+            "editType": "calc",
+            "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
+          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='mesh3d'))"
+        },
+        "lightposition": {
+          "editType": "calc",
           "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
+          "x": {
+            "description": "Numeric vector, representing the X coordinate for each vertex.",
+            "dflt": 100000,
             "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          },
+          "y": {
+            "description": "Numeric vector, representing the Y coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+          },
+          "z": {
+            "description": "Numeric vector, representing the Z coordinate for each vertex.",
+            "dflt": 0,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
           },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='isosurface'))"
+          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='mesh3d'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='isosurface'))"
+        "xcalendar": {
+          "description": "Sets the calendar system to use with `x` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(xcalendar=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "ycalendar": {
+          "description": "Sets the calendar system to use with `y` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(ycalendar=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "zcalendar": {
+          "description": "Sets the calendar system to use with `z` date data.",
+          "dflt": "gregorian",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "chinese",
+            "coptic",
+            "discworld",
+            "ethiopian",
+            "gregorian",
+            "hebrew",
+            "islamic",
+            "jalali",
+            "julian",
+            "mayan",
+            "nanakshahi",
+            "nepali",
+            "persian",
+            "taiwan",
+            "thai",
+            "ummalqura"
+          ],
+          "magic_underscores": "fig.update_traces(zcalendar=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='mesh3d'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='mesh3d'))"
       },
       "categories": [
         "gl3d",
         "showLegend"
       ],
       "meta": {
-        "description": "Draws isosurfaces between iso-min and iso-max values with coordinates given by four 1-dimensional arrays containing the `value`, `x`, `y` and `z` of every vertex of a uniform or non-uniform 3-D grid. Horizontal or vertical slices, caps as well as spaceframe between iso-min and iso-max values could also be drawn using this trace."
+        "description": "Draws sets of triangles with coordinates given by three 1-dimensional arrays in `x`, `y`, `z` and (1) a sets of `i`, `j`, `k` indices (2) Delaunay triangulation or (3) the Alpha-shape algorithm or (4) the Convex-hull algorithm"
       },
-      "type": "isosurface"
+      "type": "mesh3d"
     },
-    "scattergeo": {
+    "cone": {
       "animatable": false,
       "attributes": {
-        "type": "scattergeo",
+        "type": "cone",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -64787,35 +54323,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
+          "dflt": false,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -64823,7 +54359,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -64833,7 +54369,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -64848,7 +54384,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "role": "object",
             "shadow": {
@@ -64856,13 +54392,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -64873,7 +54409,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -64886,7 +54422,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -64901,7 +54437,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -64914,9 +54450,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='cone'))"
           },
           "role": "object",
           "text": {
@@ -64924,172 +54460,88 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='cone'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "opacity": {
-          "description": "Sets the opacity of the trace.",
+          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
           "dflt": 1,
-          "editType": "style",
+          "editType": "calc",
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "mode": {
-          "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points and the trace is not stacked then the default is *lines+markers*. Otherwise, *lines*.",
-          "dflt": "markers",
-          "editType": "calc",
-          "extras": [
-            "none"
-          ],
-          "flags": [
-            "lines",
-            "markers",
-            "text"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "lat": {
-          "description": "Sets the latitude coordinates (in degrees North).",
-          "editType": "calc",
+        "x": {
+          "description": "Sets the x coordinates of the vector field and of the displayed cones.",
+          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "latsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lat`.",
-          "editType": "none",
-          "valType": "string"
+        "y": {
+          "description": "Sets the y coordinates of the vector field and of the displayed cones.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "geojson": {
-          "description": "Sets optional GeoJSON data associated with this trace. If not given, the features on the base map are used when `locations` is set. It can be set as a valid GeoJSON object or as a URL string. Note that we only accept GeoJSONs of type *FeatureCollection* or *Feature* with geometries of type *Polygon* or *MultiPolygon*.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(geojson=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+        "z": {
+          "description": "Sets the z coordinates of the vector field and of the displayed cones.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "featureidkey": {
-          "description": "Sets the key in GeoJSON features which is used as id to match the items included in the `locations` array. Only has an effect when `geojson` is set. Support nested property, for example *properties.name*.",
-          "dflt": "id",
+        "u": {
+          "description": "Sets the x components of the vector field.",
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(featureidkey=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(u=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "locations": {
-          "description": "Sets the coordinates via location IDs or names. Coordinates correspond to the centroid of each location given. See `locationmode` for more info.",
+        "v": {
+          "description": "Sets the y components of the vector field.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(locations=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "locationssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(v=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "lon": {
-          "description": "Sets the longitude coordinates (in degrees East).",
+        "w": {
+          "description": "Sets the z components of the vector field.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "lonsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lon`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(w=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "textposition": {
-          "arrayOk": true,
-          "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
-          "dflt": "middle center",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "top left",
-            "top center",
-            "top right",
-            "middle left",
-            "middle center",
-            "middle right",
-            "bottom left",
-            "bottom center",
-            "bottom right"
-          ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "texttemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `lat`, `lon`, `location` and `text`.",
+          "description": "Sets the text elements associated with the cones. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "texttemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "hovertext": {
           "arrayOk": true,
-          "description": "Sets hover text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "description": "Same as `text`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
-          "dflt": "all",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "dflt": "x+y+z+norm+text+name",
           "editType": "calc",
           "extras": [
             "all",
@@ -65097,398 +54549,593 @@
             "skip"
           ],
           "flags": [
-            "lon",
-            "lat",
-            "location",
+            "x",
+            "y",
+            "z",
+            "u",
+            "v",
+            "w",
+            "norm",
             "text",
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `norm` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
           "editType": "none",
-          "valType": "string"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "uhoverformat": {
+          "description": "Sets the hover text formatting rule for `u` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "vhoverformat": {
+          "description": "Sets the hover text formatting rule for `v` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(vhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "whoverformat": {
+          "description": "Sets the hover text formatting rule for `w` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(whoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+        "scene": {
+          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
+          "dflt": "scene",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "geo": {
-          "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on.",
-          "dflt": "geo",
+        "coloraxis": {
+          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+          "dflt": null,
           "editType": "calc",
+          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(geo=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='cone'))"
         },
-        "marker": {
-          "angle": {
-            "arrayOk": true,
-            "description": "Sets the marker angle in respect to `angleref`.",
+        "colorbar": {
+          "bgcolor": {
+            "description": "Sets the color of padded area.",
+            "dflt": "rgba(0,0,0,0)",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "bordercolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "borderwidth": {
+            "description": "Sets the width (in px) or the border enclosing this color bar.",
+            "dflt": 0,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "dtick": {
+            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+            },
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "editType": "colorbars",
+          "exponentformat": {
+            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+            "dflt": "B",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "none",
+              "e",
+              "E",
+              "power",
+              "SI",
+              "B",
+              "SI extended"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "labelalias": {
+            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+            "dflt": false,
+            "editType": "colorbars",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "len": {
+            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "lenmode": {
+            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+            "dflt": "fraction",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "minexponent": {
+            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+            "dflt": 3,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "nticks": {
+            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
             "dflt": 0,
-            "editType": "calc",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "angleref": {
-            "description": "Sets the reference for marker angle. With *previous*, angle 0 points along the line from the previous point to this one. With *up*, angle 0 points toward the top of the screen. With *north*, angle 0 points north based on the current map projection.",
-            "dflt": "up",
-            "editType": "calc",
+          "orientation": {
+            "description": "Sets the orientation of the colorbar.",
+            "dflt": "v",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "previous",
-              "up",
-              "north"
+              "h",
+              "v"
             ],
-            "magic_underscores": "fig.update_traces(marker_angleref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
+          "outlinecolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "autocolorscale": {
-            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-            "dflt": true,
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
+          "outlinewidth": {
+            "description": "Sets the width (in px) of the axis line.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "role": "object",
+          "separatethousands": {
+            "description": "If \"true\", even 4-digit integers are separated",
+            "dflt": false,
+            "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "cauto": {
-            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
+          "showexponent": {
+            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "showticklabels": {
+            "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
+            "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "cmax": {
-            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "showtickprefix": {
+            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "cmid": {
-            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
+          "showticksuffix": {
+            "description": "Same as `showtickprefix` but for tick suffixes.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "thickness": {
+            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+            "dflt": 30,
+            "editType": "colorbars",
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "cmin": {
-            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
-            "dflt": null,
-            "editType": "calc",
+          "thicknessmode": {
+            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+            "dflt": "pixels",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "tick0": {
+            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+            "editType": "colorbars",
             "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "color": {
-            "arrayOk": true,
-            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "tickangle": {
+            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+            "dflt": "auto",
+            "editType": "colorbars",
+            "valType": "angle",
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "coloraxis": {
-            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-            "dflt": null,
-            "editType": "calc",
-            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-            "valType": "subplotid",
-            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "tickcolor": {
+            "description": "Sets the tick color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "colorbar": {
-            "bgcolor": {
-              "description": "Sets the color of padded area.",
-              "dflt": "rgba(0,0,0,0)",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "bordercolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
-              "editType": "calc",
+          "tickfont": {
+            "color": {
+              "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "borderwidth": {
-              "description": "Sets the width (in px) or the border enclosing this color bar.",
-              "dflt": 0,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "dtick": {
-              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-              "editType": "calc",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "editType": "calc",
-            "exponentformat": {
-              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-              "dflt": "B",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "none",
-                "e",
-                "E",
-                "power",
-                "SI",
-                "B",
-                "SI extended"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "labelalias": {
-              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "len": {
-              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "description": "Sets the color bar's tick label font",
+            "editType": "colorbars",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "colorbars",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "lenmode": {
-              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-              "dflt": "fraction",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "colorbars",
+              "extras": [
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "minexponent": {
-              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-              "dflt": 3,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "nticks": {
-              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-              "dflt": 0,
-              "editType": "calc",
-              "min": 0,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "orientation": {
-              "description": "Sets the orientation of the colorbar.",
-              "dflt": "v",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "h",
-                "v"
+              "flags": [
+                "under",
+                "over",
+                "through"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "outlinecolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "outlinewidth": {
-              "description": "Sets the width (in px) of the axis line.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
+            "size": {
+              "editType": "colorbars",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "role": "object",
-            "separatethousands": {
-              "description": "If \"true\", even 4-digit integers are separated",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "showexponent": {
-              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-              "dflt": "all",
-              "editType": "calc",
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "showticklabels": {
-              "description": "Determines whether or not the tick labels are drawn.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "showtickprefix": {
-              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-              "dflt": "all",
-              "editType": "calc",
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "showticksuffix": {
-              "description": "Same as `showtickprefix` but for tick suffixes.",
-              "dflt": "all",
-              "editType": "calc",
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "thickness": {
-              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-              "dflt": 30,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "thicknessmode": {
-              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-              "dflt": "pixels",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "extras": [
+                "normal",
+                "bold"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "tick0": {
-              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-              "editType": "calc",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "tickangle": {
-              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-              "dflt": "auto",
-              "editType": "calc",
-              "valType": "angle",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='cone'))"
+          },
+          "tickformat": {
+            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "tickformatstops": {
+            "items": {
+              "tickformatstop": {
+                "dtickrange": {
+                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                  "editType": "colorbars",
+                  "items": [
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    },
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    }
+                  ],
+                  "valType": "info_array"
+                },
+                "editType": "colorbars",
+                "enabled": {
+                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                  "dflt": true,
+                  "editType": "colorbars",
+                  "valType": "boolean"
+                },
+                "name": {
+                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "role": "object",
+                "templateitemname": {
+                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "value": {
+                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                  "dflt": "",
+                  "editType": "colorbars",
+                  "valType": "string"
+                }
+              }
             },
-            "tickcolor": {
-              "description": "Sets the tick color.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "role": "object",
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='cone'))"
+          },
+          "ticklabeloverflow": {
+            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "allow",
+              "hide past div",
+              "hide past domain"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "ticklabelposition": {
+            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+            "dflt": "outside",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              "outside top",
+              "inside top",
+              "outside left",
+              "inside left",
+              "outside right",
+              "inside right",
+              "outside bottom",
+              "inside bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "ticklabelstep": {
+            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "ticklen": {
+            "description": "Sets the tick length (in px).",
+            "dflt": 5,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "tickmode": {
+            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "tickfont": {
+            "valType": "enumerated",
+            "values": [
+              "auto",
+              "linear",
+              "array"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "tickprefix": {
+            "description": "Sets a tick label prefix.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "ticks": {
+            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              ""
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "ticksuffix": {
+            "description": "Sets a tick label suffix.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "ticktext": {
+            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "tickvals": {
+            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "tickwidth": {
+            "description": "Sets the tick width (in px).",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "title": {
+            "editType": "colorbars",
+            "font": {
               "color": {
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
-              "description": "Sets the color bar's tick label font",
-              "editType": "calc",
+              "description": "Sets this color bar's title font.",
+              "editType": "colorbars",
               "family": {
                 "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "calc",
+                "editType": "colorbars",
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
                 "dflt": "none",
-                "editType": "calc",
+                "editType": "colorbars",
                 "extras": [
                   "none"
                 ],
@@ -65498,37 +55145,37 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
               "role": "object",
               "shadow": {
                 "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
                 "dflt": "none",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
               "size": {
-                "editType": "calc",
+                "editType": "colorbars",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -65536,12 +55183,12 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -65551,12 +55198,12 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
                 "dflt": "normal",
-                "editType": "calc",
+                "editType": "colorbars",
                 "extras": [
                   "normal",
                   "bold"
@@ -65564,1443 +55211,1587 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='scattergeo'))"
-            },
-            "tickformat": {
-              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "tickformatstops": {
-              "items": {
-                "tickformatstop": {
-                  "dtickrange": {
-                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                    "editType": "calc",
-                    "items": [
-                      {
-                        "editType": "calc",
-                        "valType": "any"
-                      },
-                      {
-                        "editType": "calc",
-                        "valType": "any"
-                      }
-                    ],
-                    "valType": "info_array"
-                  },
-                  "editType": "calc",
-                  "enabled": {
-                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                    "dflt": true,
-                    "editType": "calc",
-                    "valType": "boolean"
-                  },
-                  "name": {
-                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                    "editType": "calc",
-                    "valType": "string"
-                  },
-                  "role": "object",
-                  "templateitemname": {
-                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                    "editType": "calc",
-                    "valType": "string"
-                  },
-                  "value": {
-                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                    "dflt": "",
-                    "editType": "calc",
-                    "valType": "string"
-                  }
-                }
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
               },
-              "role": "object",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='scattergeo'))"
-            },
-            "ticklabeloverflow": {
-              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "allow",
-                "hide past div",
-                "hide past domain"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='cone'))"
             },
-            "ticklabelposition": {
-              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-              "dflt": "outside",
-              "editType": "calc",
+            "role": "object",
+            "side": {
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+              "editType": "colorbars",
               "valType": "enumerated",
               "values": [
-                "outside",
-                "inside",
-                "outside top",
-                "inside top",
-                "outside left",
-                "inside left",
-                "outside right",
-                "inside right",
-                "outside bottom",
-                "inside bottom"
+                "right",
+                "top",
+                "bottom"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "ticklabelstep": {
-              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "ticklen": {
-              "description": "Sets the tick length (in px).",
-              "dflt": 5,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "text": {
+              "description": "Sets the title of the color bar.",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "tickmode": {
-              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "enumerated",
-              "values": [
-                "auto",
-                "linear",
-                "array"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='cone'))"
+          },
+          "x": {
+            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+            "editType": "colorbars",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "xanchor": {
+            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "center",
+              "right"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "xpad": {
+            "description": "Sets the amount of padding (in px) along the x direction.",
+            "dflt": 10,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "xref": {
+            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "container",
+              "paper"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "y": {
+            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+            "editType": "colorbars",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "yanchor": {
+            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "top",
+              "middle",
+              "bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "ypad": {
+            "description": "Sets the amount of padding (in px) along the y direction.",
+            "dflt": 10,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "yref": {
+            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "container",
+              "paper"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='cone'))"
+        },
+        "autocolorscale": {
+          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+          "dflt": true,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "colorscale": {
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "autocolorscale": false,
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "valType": "colorscale",
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "showscale": {
+          "description": "Determines whether or not a colorbar is displayed for this trace.",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "reversescale": {
+          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
+          "dflt": false,
+          "editType": "plot",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "zhoverformat": {
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "cauto": {
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here u/v/w norm) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
+          "dflt": true,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "cmax": {
+          "description": "Sets the upper bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmin` must be set as well.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "cmid": {
+          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as u/v/w norm. Has no effect when `cauto` is `false`.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "cmin": {
+          "description": "Sets the lower bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmax` must be set as well.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "anchor": {
+          "description": "Sets the cones' anchor with respect to their x/y/z positions. Note that *cm* denote the cone's center of mass which corresponds to 1/4 from the tail to tip.",
+          "dflt": "cm",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "tip",
+            "tail",
+            "cm",
+            "center"
+          ],
+          "magic_underscores": "fig.update_traces(anchor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "hoverlabel": {
+          "align": {
+            "arrayOk": true,
+            "description": "Sets the horizontal alignment of the text content within hover label box. Has an effect only if the hover label text spans more two or more lines",
+            "dflt": "auto",
+            "editType": "none",
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "right",
+              "auto"
+            ],
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "bgcolor": {
+            "arrayOk": true,
+            "description": "Sets the background color of the hover labels for this trace",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "bordercolor": {
+            "arrayOk": true,
+            "description": "Sets the border color of the hover labels for this trace.",
+            "editType": "none",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "editType": "none",
+          "font": {
+            "color": {
+              "arrayOk": true,
+              "editType": "none",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "tickprefix": {
-              "description": "Sets a tick label prefix.",
-              "dflt": "",
-              "editType": "calc",
+            "description": "Sets the font used in hover labels.",
+            "editType": "none",
+            "family": {
+              "arrayOk": true,
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "none",
+              "noBlank": true,
+              "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "ticks": {
-              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                ""
+            "lineposition": {
+              "arrayOk": true,
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "none",
+              "extras": [
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "ticksuffix": {
-              "description": "Sets a tick label suffix.",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "ticktext": {
-              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
+            "role": "object",
+            "shadow": {
+              "arrayOk": true,
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
               "editType": "none",
-              "valType": "string"
-            },
-            "tickvals": {
-              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
+            "size": {
+              "arrayOk": true,
               "editType": "none",
-              "valType": "string"
-            },
-            "tickwidth": {
-              "description": "Sets the tick width (in px).",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "title": {
-              "editType": "calc",
-              "font": {
-                "color": {
-                  "editType": "calc",
-                  "valType": "color",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "description": "Sets this color bar's title font.",
-                "editType": "calc",
-                "family": {
-                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                  "editType": "calc",
-                  "noBlank": true,
-                  "strict": true,
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "lineposition": {
-                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                  "dflt": "none",
-                  "editType": "calc",
-                  "extras": [
-                    "none"
-                  ],
-                  "flags": [
-                    "under",
-                    "over",
-                    "through"
-                  ],
-                  "valType": "flaglist",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "role": "object",
-                "shadow": {
-                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                  "dflt": "none",
-                  "editType": "calc",
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "size": {
-                  "editType": "calc",
-                  "min": 1,
-                  "valType": "number",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "style": {
-                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "italic"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "textcase": {
-                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "word caps",
-                    "upper",
-                    "lower"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "variant": {
-                  "description": "Sets the variant of the font.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "small-caps",
-                    "all-small-caps",
-                    "all-petite-caps",
-                    "petite-caps",
-                    "unicase"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "weight": {
-                  "description": "Sets the weight (or boldness) of the font.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "extras": [
-                    "normal",
-                    "bold"
-                  ],
-                  "max": 1000,
-                  "min": 1,
-                  "valType": "integer",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-                },
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='scattergeo'))"
-              },
-              "role": "object",
-              "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "right",
-                  "top",
-                  "bottom"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "text": {
-                "description": "Sets the title of the color bar.",
-                "editType": "calc",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='scattergeo'))"
-            },
-            "x": {
-              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-              "editType": "calc",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "xanchor": {
-              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-              "editType": "calc",
+            "style": {
+              "arrayOk": true,
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
-                "left",
-                "center",
-                "right"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "xpad": {
-              "description": "Sets the amount of padding (in px) along the x direction.",
-              "dflt": 10,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "xref": {
-              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-              "dflt": "paper",
-              "editType": "calc",
+            "textcase": {
+              "arrayOk": true,
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
-                "container",
-                "paper"
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "y": {
-              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "yanchor": {
-              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-              "editType": "calc",
+            "variant": {
+              "arrayOk": true,
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "none",
               "valType": "enumerated",
               "values": [
-                "top",
-                "middle",
-                "bottom"
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "ypad": {
-              "description": "Sets the amount of padding (in px) along the y direction.",
-              "dflt": 10,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "yref": {
-              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-              "dflt": "paper",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
+            "weight": {
+              "arrayOk": true,
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "none",
+              "extras": [
+                "normal",
+                "bold"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='cone'))"
             },
-            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='cone'))"
           },
-          "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "autocolorscale": false,
-              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "valType": "colorscale",
-            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "namelength": {
+            "arrayOk": true,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
+          "role": "object",
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
             "editType": "none",
-            "valType": "string"
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='cone'))"
+        },
+        "lighting": {
+          "ambient": {
+            "description": "Ambient light increases overall color visibility but can wash out the image.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "diffuse": {
+            "description": "Represents the extent that incident rays are reflected in a range of angles.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='cone'))"
           },
           "editType": "calc",
-          "gradient": {
+          "facenormalsepsilon": {
+            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-06,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "fresnel": {
+            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
+            "dflt": 0.2,
+            "editType": "calc",
+            "max": 5,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "role": "object",
+          "roughness": {
+            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
+            "dflt": 0.5,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "specular": {
+            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
+            "dflt": 0.05,
+            "editType": "calc",
+            "max": 2,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "vertexnormalsepsilon": {
+            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-12,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='cone'))"
+        },
+        "lightposition": {
+          "editType": "calc",
+          "role": "object",
+          "x": {
+            "description": "Numeric vector, representing the X coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "y": {
+            "description": "Numeric vector, representing the Y coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "z": {
+            "description": "Numeric vector, representing the Z coordinate for each vertex.",
+            "dflt": 0,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='cone'))"
+          },
+          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='cone'))"
+        },
+        "sizemode": {
+          "description": "Determines whether `sizeref` is set as a *scaled* (i.e unitless) scalar (normalized by the max u/v/w norm in the vector field) or as *absolute* value (in the same units as the vector field). To display sizes in actual vector length use *raw*.",
+          "dflt": "scaled",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "scaled",
+            "absolute",
+            "raw"
+          ],
+          "magic_underscores": "fig.update_traces(sizemode=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "sizeref": {
+          "description": "Adjusts the cone size scaling. The size of the cones is determined by their u/v/w norm multiplied a factor and `sizeref`. This factor (computed internally) corresponds to the minimum \"time\" to travel across two successive x/y/z positions at the average velocity of those two successive positions. All cones in a given trace use the same factor. With `sizemode` set to *raw*, its default value is *1*. With `sizemode` set to *scaled*, `sizeref` is unitless, its default value is *0.5*. With `sizemode` set to *absolute*, `sizeref` has the same units as the u/v/w vector field, its the default value is half the sample's maximum vector norm.",
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(sizeref=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='cone'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='cone'))"
+      },
+      "categories": [
+        "gl3d",
+        "showLegend"
+      ],
+      "meta": {
+        "description": "Use cone traces to visualize vector fields.  Specify a vector field using 6 1D arrays, 3 position arrays `x`, `y` and `z` and 3 vector component arrays `u`, `v`, `w`. The cones are drawn exactly at the positions given by `x`, `y` and `z`."
+      },
+      "type": "cone"
+    },
+    "streamtube": {
+      "animatable": false,
+      "attributes": {
+        "type": "streamtube",
+        "name": {
+          "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "uid": {
+          "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
+          "editType": "plot",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "visible": {
+          "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            true,
+            false,
+            "legendonly"
+          ],
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "showlegend": {
+          "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
+          "dflt": false,
+          "editType": "style",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "legend": {
+          "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
+          "dflt": "legend",
+          "editType": "style",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "legendrank": {
+          "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
+          "dflt": 1000,
+          "editType": "style",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "legendgroup": {
+          "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
+          "dflt": "",
+          "editType": "style",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "legendgrouptitle": {
+          "editType": "style",
+          "font": {
             "color": {
-              "arrayOk": true,
-              "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical.",
-              "editType": "calc",
+              "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_gradient_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "description": "Sets this legend group's title font.",
+            "editType": "style",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "style",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "editType": "calc",
-            "role": "object",
-            "type": {
-              "arrayOk": true,
-              "description": "Sets the type of gradient used to fill the markers",
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "radial",
-                "horizontal",
-                "vertical",
+              "editType": "style",
+              "extras": [
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_gradient_type=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "typesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `type`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(marker_gradient=dict(...), selector=dict(type='scattergeo'))"
-          },
-          "line": {
-            "autocolorscale": {
-              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "cauto": {
-              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
-              "dflt": true,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "cmax": {
-              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "cmid": {
-              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "style",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "cmin": {
-              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "cauto": false,
-                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
+            "size": {
+              "editType": "style",
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "coloraxis": {
-              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-              "dflt": null,
-              "editType": "calc",
-              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-              "valType": "subplotid",
-              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-              "dflt": null,
-              "editType": "calc",
-              "impliedEdits": {
-                "autocolorscale": false,
-                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-              },
-              "valType": "colorscale",
-              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "dash": {
-              "arrayOk": true,
-              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
-              "dflt": "solid",
-              "editType": "calc",
-              "valType": "string",
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
               "values": [
-                "solid",
-                "dot",
-                "dash",
-                "longdash",
-                "dashdot",
-                "longdashdot"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "dashsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "editType": "calc",
-            "reversescale": {
-              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "role": "object",
-            "width": {
-              "arrayOk": true,
-              "description": "Sets the width (in px) of the lines bounding the marker points.",
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "style",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scattergeo'))"
-          },
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the marker opacity.",
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "reversescale": {
-            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='streamtube'))"
           },
           "role": "object",
-          "showscale": {
-            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "text": {
+            "description": "Sets the title of the legend group.",
+            "dflt": "",
+            "editType": "style",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "size": {
-            "arrayOk": true,
-            "description": "Sets the marker size (in px).",
-            "dflt": 6,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='streamtube'))"
+        },
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
+          "dflt": 1,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "x": {
+          "description": "Sets the x coordinates of the vector field.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "y": {
+          "description": "Sets the y coordinates of the vector field.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "z": {
+          "description": "Sets the z coordinates of the vector field.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "u": {
+          "description": "Sets the x components of the vector field.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(u=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "v": {
+          "description": "Sets the y components of the vector field.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(v=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "w": {
+          "description": "Sets the z components of the vector field.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(w=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "text": {
+          "description": "Sets a text element associated with this trace. If trace `hoverinfo` contains a *text* flag, this text element will be seen in all hover labels. Note that streamtube traces do not support array `text` values.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "hovertext": {
+          "description": "Same as `text`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "hoverinfo": {
+          "arrayOk": true,
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "dflt": "x+y+z+norm+text+name",
+          "editType": "calc",
+          "extras": [
+            "all",
+            "none",
+            "skip"
+          ],
+          "flags": [
+            "x",
+            "y",
+            "z",
+            "u",
+            "v",
+            "w",
+            "norm",
+            "divergence",
+            "text",
+            "name"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "hovertemplate": {
+          "arrayOk": true,
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `tubex`, `tubey`, `tubez`, `tubeu`, `tubev`, `tubew`, `norm` and `divergence`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "hovertemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "uhoverformat": {
+          "description": "Sets the hover text formatting rule for `u` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(uhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "vhoverformat": {
+          "description": "Sets the hover text formatting rule for `v` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(vhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "whoverformat": {
+          "description": "Sets the hover text formatting rule for `w` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(whoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "meta": {
+          "arrayOk": true,
+          "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
+          "editType": "plot",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "customdata": {
+          "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "scene": {
+          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
+          "dflt": "scene",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "coloraxis": {
+          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+          "dflt": null,
+          "editType": "calc",
+          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "colorbar": {
+          "bgcolor": {
+            "description": "Sets the color of padded area.",
+            "dflt": "rgba(0,0,0,0)",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "sizemin": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.",
+          "bordercolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "borderwidth": {
+            "description": "Sets the width (in px) or the border enclosing this color bar.",
             "dflt": 0,
-            "editType": "calc",
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizemin=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "sizemode": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.",
-            "dflt": "diameter",
-            "editType": "calc",
+          "dtick": {
+            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "editType": "colorbars",
+          "exponentformat": {
+            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+            "dflt": "B",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "diameter",
-              "area"
+              "none",
+              "e",
+              "E",
+              "power",
+              "SI",
+              "B",
+              "SI extended"
             ],
-            "magic_underscores": "fig.update_traces(marker_sizemode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "sizeref": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.",
-            "dflt": 1,
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+          "labelalias": {
+            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+            "dflt": false,
+            "editType": "colorbars",
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "standoff": {
-            "arrayOk": true,
-            "description": "Moves the marker away from the data point in the direction of `angle` (in px). This can be useful for example if you have another marker at this location and you want to point an arrowhead marker at it.",
-            "dflt": 0,
-            "editType": "calc",
+          "len": {
+            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+            "dflt": 1,
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_standoff=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "standoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `standoff`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "symbol": {
-            "arrayOk": true,
-            "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
-            "dflt": "circle",
-            "editType": "calc",
+          "lenmode": {
+            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+            "dflt": "fraction",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              0,
-              "0",
-              "circle",
-              100,
-              "100",
-              "circle-open",
-              200,
-              "200",
-              "circle-dot",
-              300,
-              "300",
-              "circle-open-dot",
-              1,
-              "1",
-              "square",
-              101,
-              "101",
-              "square-open",
-              201,
-              "201",
-              "square-dot",
-              301,
-              "301",
-              "square-open-dot",
-              2,
-              "2",
-              "diamond",
-              102,
-              "102",
-              "diamond-open",
-              202,
-              "202",
-              "diamond-dot",
-              302,
-              "302",
-              "diamond-open-dot",
-              3,
-              "3",
-              "cross",
-              103,
-              "103",
-              "cross-open",
-              203,
-              "203",
-              "cross-dot",
-              303,
-              "303",
-              "cross-open-dot",
-              4,
-              "4",
-              "x",
-              104,
-              "104",
-              "x-open",
-              204,
-              "204",
-              "x-dot",
-              304,
-              "304",
-              "x-open-dot",
-              5,
-              "5",
-              "triangle-up",
-              105,
-              "105",
-              "triangle-up-open",
-              205,
-              "205",
-              "triangle-up-dot",
-              305,
-              "305",
-              "triangle-up-open-dot",
-              6,
-              "6",
-              "triangle-down",
-              106,
-              "106",
-              "triangle-down-open",
-              206,
-              "206",
-              "triangle-down-dot",
-              306,
-              "306",
-              "triangle-down-open-dot",
-              7,
-              "7",
-              "triangle-left",
-              107,
-              "107",
-              "triangle-left-open",
-              207,
-              "207",
-              "triangle-left-dot",
-              307,
-              "307",
-              "triangle-left-open-dot",
-              8,
-              "8",
-              "triangle-right",
-              108,
-              "108",
-              "triangle-right-open",
-              208,
-              "208",
-              "triangle-right-dot",
-              308,
-              "308",
-              "triangle-right-open-dot",
-              9,
-              "9",
-              "triangle-ne",
-              109,
-              "109",
-              "triangle-ne-open",
-              209,
-              "209",
-              "triangle-ne-dot",
-              309,
-              "309",
-              "triangle-ne-open-dot",
-              10,
-              "10",
-              "triangle-se",
-              110,
-              "110",
-              "triangle-se-open",
-              210,
-              "210",
-              "triangle-se-dot",
-              310,
-              "310",
-              "triangle-se-open-dot",
-              11,
-              "11",
-              "triangle-sw",
-              111,
-              "111",
-              "triangle-sw-open",
-              211,
-              "211",
-              "triangle-sw-dot",
-              311,
-              "311",
-              "triangle-sw-open-dot",
-              12,
-              "12",
-              "triangle-nw",
-              112,
-              "112",
-              "triangle-nw-open",
-              212,
-              "212",
-              "triangle-nw-dot",
-              312,
-              "312",
-              "triangle-nw-open-dot",
-              13,
-              "13",
-              "pentagon",
-              113,
-              "113",
-              "pentagon-open",
-              213,
-              "213",
-              "pentagon-dot",
-              313,
-              "313",
-              "pentagon-open-dot",
-              14,
-              "14",
-              "hexagon",
-              114,
-              "114",
-              "hexagon-open",
-              214,
-              "214",
-              "hexagon-dot",
-              314,
-              "314",
-              "hexagon-open-dot",
-              15,
-              "15",
-              "hexagon2",
-              115,
-              "115",
-              "hexagon2-open",
-              215,
-              "215",
-              "hexagon2-dot",
-              315,
-              "315",
-              "hexagon2-open-dot",
-              16,
-              "16",
-              "octagon",
-              116,
-              "116",
-              "octagon-open",
-              216,
-              "216",
-              "octagon-dot",
-              316,
-              "316",
-              "octagon-open-dot",
-              17,
-              "17",
-              "star",
-              117,
-              "117",
-              "star-open",
-              217,
-              "217",
-              "star-dot",
-              317,
-              "317",
-              "star-open-dot",
-              18,
-              "18",
-              "hexagram",
-              118,
-              "118",
-              "hexagram-open",
-              218,
-              "218",
-              "hexagram-dot",
-              318,
-              "318",
-              "hexagram-open-dot",
-              19,
-              "19",
-              "star-triangle-up",
-              119,
-              "119",
-              "star-triangle-up-open",
-              219,
-              "219",
-              "star-triangle-up-dot",
-              319,
-              "319",
-              "star-triangle-up-open-dot",
-              20,
-              "20",
-              "star-triangle-down",
-              120,
-              "120",
-              "star-triangle-down-open",
-              220,
-              "220",
-              "star-triangle-down-dot",
-              320,
-              "320",
-              "star-triangle-down-open-dot",
-              21,
-              "21",
-              "star-square",
-              121,
-              "121",
-              "star-square-open",
-              221,
-              "221",
-              "star-square-dot",
-              321,
-              "321",
-              "star-square-open-dot",
-              22,
-              "22",
-              "star-diamond",
-              122,
-              "122",
-              "star-diamond-open",
-              222,
-              "222",
-              "star-diamond-dot",
-              322,
-              "322",
-              "star-diamond-open-dot",
-              23,
-              "23",
-              "diamond-tall",
-              123,
-              "123",
-              "diamond-tall-open",
-              223,
-              "223",
-              "diamond-tall-dot",
-              323,
-              "323",
-              "diamond-tall-open-dot",
-              24,
-              "24",
-              "diamond-wide",
-              124,
-              "124",
-              "diamond-wide-open",
-              224,
-              "224",
-              "diamond-wide-dot",
-              324,
-              "324",
-              "diamond-wide-open-dot",
-              25,
-              "25",
-              "hourglass",
-              125,
-              "125",
-              "hourglass-open",
-              26,
-              "26",
-              "bowtie",
-              126,
-              "126",
-              "bowtie-open",
-              27,
-              "27",
-              "circle-cross",
-              127,
-              "127",
-              "circle-cross-open",
-              28,
-              "28",
-              "circle-x",
-              128,
-              "128",
-              "circle-x-open",
-              29,
-              "29",
-              "square-cross",
-              129,
-              "129",
-              "square-cross-open",
-              30,
-              "30",
-              "square-x",
-              130,
-              "130",
-              "square-x-open",
-              31,
-              "31",
-              "diamond-cross",
-              131,
-              "131",
-              "diamond-cross-open",
-              32,
-              "32",
-              "diamond-x",
-              132,
-              "132",
-              "diamond-x-open",
-              33,
-              "33",
-              "cross-thin",
-              133,
-              "133",
-              "cross-thin-open",
-              34,
-              "34",
-              "x-thin",
-              134,
-              "134",
-              "x-thin-open",
-              35,
-              "35",
-              "asterisk",
-              135,
-              "135",
-              "asterisk-open",
-              36,
-              "36",
-              "hash",
-              136,
-              "136",
-              "hash-open",
-              236,
-              "236",
-              "hash-dot",
-              336,
-              "336",
-              "hash-open-dot",
-              37,
-              "37",
-              "y-up",
-              137,
-              "137",
-              "y-up-open",
-              38,
-              "38",
-              "y-down",
-              138,
-              "138",
-              "y-down-open",
-              39,
-              "39",
-              "y-left",
-              139,
-              "139",
-              "y-left-open",
-              40,
-              "40",
-              "y-right",
-              140,
-              "140",
-              "y-right-open",
-              41,
-              "41",
-              "line-ew",
-              141,
-              "141",
-              "line-ew-open",
-              42,
-              "42",
-              "line-ns",
-              142,
-              "142",
-              "line-ns-open",
-              43,
-              "43",
-              "line-ne",
-              143,
-              "143",
-              "line-ne-open",
-              44,
-              "44",
-              "line-nw",
-              144,
-              "144",
-              "line-nw-open",
-              45,
-              "45",
-              "arrow-up",
-              145,
-              "145",
-              "arrow-up-open",
-              46,
-              "46",
-              "arrow-down",
-              146,
-              "146",
-              "arrow-down-open",
-              47,
-              "47",
-              "arrow-left",
-              147,
-              "147",
-              "arrow-left-open",
-              48,
-              "48",
-              "arrow-right",
-              148,
-              "148",
-              "arrow-right-open",
-              49,
-              "49",
-              "arrow-bar-up",
-              149,
-              "149",
-              "arrow-bar-up-open",
-              50,
-              "50",
-              "arrow-bar-down",
-              150,
-              "150",
-              "arrow-bar-down-open",
-              51,
-              "51",
-              "arrow-bar-left",
-              151,
-              "151",
-              "arrow-bar-left-open",
-              52,
-              "52",
-              "arrow-bar-right",
-              152,
-              "152",
-              "arrow-bar-right-open",
-              53,
-              "53",
-              "arrow",
-              153,
-              "153",
-              "arrow-open",
-              54,
-              "54",
-              "arrow-wide",
-              154,
-              "154",
-              "arrow-wide-open"
+              "fraction",
+              "pixels"
             ],
-            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "minexponent": {
+            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+            "dflt": 3,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "nticks": {
+            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+            "dflt": 0,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
+          "orientation": {
+            "description": "Sets the orientation of the colorbar.",
+            "dflt": "v",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "h",
+              "v"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattergeo'))"
-        },
-        "line": {
-          "color": {
-            "description": "Sets the line color.",
-            "editType": "calc",
+          "outlinecolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "dash": {
-            "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
-            "dflt": "solid",
-            "editType": "calc",
-            "valType": "string",
+          "outlinewidth": {
+            "description": "Sets the width (in px) of the axis line.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "role": "object",
+          "separatethousands": {
+            "description": "If \"true\", even 4-digit integers are separated",
+            "dflt": false,
+            "editType": "colorbars",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "showexponent": {
+            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
             "values": [
-              "solid",
-              "dot",
-              "dash",
-              "longdash",
-              "dashdot",
-              "longdashdot"
+              "all",
+              "first",
+              "last",
+              "none"
             ],
-            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "editType": "calc",
-          "role": "object",
-          "width": {
-            "description": "Sets the line width (in px).",
-            "dflt": 2,
-            "editType": "calc",
+          "showticklabels": {
+            "description": "Determines whether or not the tick labels are drawn.",
+            "dflt": true,
+            "editType": "colorbars",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "showtickprefix": {
+            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "showticksuffix": {
+            "description": "Same as `showtickprefix` but for tick suffixes.",
+            "dflt": "all",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "thickness": {
+            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+            "dflt": 30,
+            "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='scattergeo'))"
-        },
-        "textfont": {
-          "color": {
-            "arrayOk": true,
-            "editType": "calc",
+          "thicknessmode": {
+            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+            "dflt": "pixels",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "tick0": {
+            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "tickangle": {
+            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+            "dflt": "auto",
+            "editType": "colorbars",
+            "valType": "angle",
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "tickcolor": {
+            "description": "Sets the tick color.",
+            "dflt": "#444",
+            "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+          "tickfont": {
+            "color": {
+              "editType": "colorbars",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "description": "Sets the color bar's tick label font",
+            "editType": "colorbars",
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+              "editType": "colorbars",
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
+              "editType": "colorbars",
+              "extras": [
+                "none"
+              ],
+              "flags": [
+                "under",
+                "over",
+                "through"
+              ],
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "size": {
+              "editType": "colorbars",
+              "min": 1,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "italic"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
+              "editType": "colorbars",
+              "extras": [
+                "normal",
+                "bold"
+              ],
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='streamtube'))"
           },
-          "description": "Sets the text font.",
-          "editType": "calc",
-          "family": {
-            "arrayOk": true,
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
+          "tickformat": {
+            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+            "dflt": "",
+            "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
+          "tickformatstops": {
+            "items": {
+              "tickformatstop": {
+                "dtickrange": {
+                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                  "editType": "colorbars",
+                  "items": [
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    },
+                    {
+                      "editType": "colorbars",
+                      "valType": "any"
+                    }
+                  ],
+                  "valType": "info_array"
+                },
+                "editType": "colorbars",
+                "enabled": {
+                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                  "dflt": true,
+                  "editType": "colorbars",
+                  "valType": "boolean"
+                },
+                "name": {
+                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "role": "object",
+                "templateitemname": {
+                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                  "editType": "colorbars",
+                  "valType": "string"
+                },
+                "value": {
+                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                  "dflt": "",
+                  "editType": "colorbars",
+                  "valType": "string"
+                }
+              }
+            },
+            "role": "object",
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='streamtube'))"
           },
-          "lineposition": {
-            "arrayOk": true,
-            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-            "dflt": "none",
-            "editType": "calc",
-            "extras": [
-              "none"
+          "ticklabeloverflow": {
+            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "allow",
+              "hide past div",
+              "hide past domain"
             ],
-            "flags": [
-              "under",
-              "over",
-              "through"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "ticklabelposition": {
+            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+            "dflt": "outside",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              "outside top",
+              "inside top",
+              "outside left",
+              "inside left",
+              "outside right",
+              "inside right",
+              "outside bottom",
+              "inside bottom"
             ],
-            "valType": "flaglist",
-            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
+          "ticklabelstep": {
+            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "role": "object",
-          "shadow": {
-            "arrayOk": true,
-            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-            "dflt": "none",
-            "editType": "calc",
+          "ticklen": {
+            "description": "Sets the tick length (in px).",
+            "dflt": 5,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "tickmode": {
+            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+            "editType": "colorbars",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "valType": "enumerated",
+            "values": [
+              "auto",
+              "linear",
+              "array"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "tickprefix": {
+            "description": "Sets a tick label prefix.",
+            "dflt": "",
+            "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
+          "ticks": {
+            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              ""
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "ticksuffix": {
+            "description": "Sets a tick label suffix.",
+            "dflt": "",
+            "editType": "colorbars",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "ticktext": {
+            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "tickvals": {
+            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+            "editType": "colorbars",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "tickwidth": {
+            "description": "Sets the tick width (in px).",
+            "dflt": 1,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "title": {
+            "editType": "colorbars",
+            "font": {
+              "color": {
+                "editType": "colorbars",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "description": "Sets this color bar's title font.",
+              "editType": "colorbars",
+              "family": {
+                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                "editType": "colorbars",
+                "noBlank": true,
+                "strict": true,
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "lineposition": {
+                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "extras": [
+                  "none"
+                ],
+                "flags": [
+                  "under",
+                  "over",
+                  "through"
+                ],
+                "valType": "flaglist",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "role": "object",
+              "shadow": {
+                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                "dflt": "none",
+                "editType": "colorbars",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "size": {
+                "editType": "colorbars",
+                "min": 1,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "style": {
+                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "italic"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "textcase": {
+                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "colorbars",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+              },
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='streamtube'))"
+            },
+            "role": "object",
+            "side": {
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+              "editType": "colorbars",
+              "valType": "enumerated",
+              "values": [
+                "right",
+                "top",
+                "bottom"
+              ],
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "text": {
+              "description": "Sets the title of the color bar.",
+              "editType": "colorbars",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+            },
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='streamtube'))"
           },
-          "size": {
-            "arrayOk": true,
-            "editType": "calc",
-            "min": 1,
+          "x": {
+            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+            "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "style": {
-            "arrayOk": true,
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
-            "editType": "calc",
+          "xanchor": {
+            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "italic"
+              "left",
+              "center",
+              "right"
             ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
+          "xpad": {
+            "description": "Sets the amount of padding (in px) along the x direction.",
+            "dflt": 10,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "textcase": {
-            "arrayOk": true,
-            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-            "dflt": "normal",
-            "editType": "calc",
+          "xref": {
+            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "word caps",
-              "upper",
-              "lower"
+              "container",
+              "paper"
             ],
-            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
+          "y": {
+            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+            "editType": "colorbars",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "variant": {
-            "arrayOk": true,
-            "description": "Sets the variant of the font.",
-            "dflt": "normal",
-            "editType": "calc",
+          "yanchor": {
+            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+            "editType": "colorbars",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "small-caps",
-              "all-small-caps",
-              "all-petite-caps",
-              "petite-caps",
-              "unicase"
+              "top",
+              "middle",
+              "bottom"
             ],
-            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
+          "ypad": {
+            "description": "Sets the amount of padding (in px) along the y direction.",
+            "dflt": 10,
+            "editType": "colorbars",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "weight": {
-            "arrayOk": true,
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "calc",
-            "extras": [
-              "normal",
-              "bold"
+          "yref": {
+            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+            "dflt": "paper",
+            "editType": "colorbars",
+            "valType": "enumerated",
+            "values": [
+              "container",
+              "paper"
             ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='streamtube'))"
         },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+        "autocolorscale": {
+          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+          "dflt": true,
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
         },
-        "selected": {
+        "colorscale": {
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "dflt": null,
           "editType": "calc",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of selected points.",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "editType": "calc",
-            "opacity": {
-              "description": "Sets the marker opacity of selected points.",
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "role": "object",
-            "size": {
-              "description": "Sets the marker size of selected points.",
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='scattergeo'))"
-          },
-          "role": "object",
-          "textfont": {
-            "color": {
-              "description": "Sets the text font color of selected points.",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_textfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "editType": "calc",
-            "role": "object",
-            "magic_underscores": "fig.update_traces(selected_textfont=dict(...), selector=dict(type='scattergeo'))"
+          "impliedEdits": {
+            "autocolorscale": false,
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='scattergeo'))"
+          "valType": "colorscale",
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
         },
-        "unselected": {
+        "showscale": {
+          "description": "Determines whether or not a colorbar is displayed for this trace.",
+          "dflt": true,
           "editType": "calc",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "editType": "calc",
-            "opacity": {
-              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
-              "editType": "calc",
-              "max": 1,
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "role": "object",
-            "size": {
-              "description": "Sets the marker size of unselected points, applied only when a selection exists.",
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='scattergeo'))"
-          },
-          "role": "object",
-          "textfont": {
-            "color": {
-              "description": "Sets the text font color of unselected points, applied only when a selection exists.",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_textfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "editType": "calc",
-            "role": "object",
-            "magic_underscores": "fig.update_traces(unselected_textfont=dict(...), selector=dict(type='scattergeo'))"
-          },
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='scattergeo'))"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
         },
-        "connectgaps": {
-          "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.",
+        "reversescale": {
+          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
           "dflt": false,
+          "editType": "plot",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "zhoverformat": {
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "none",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "cauto": {
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here u/v/w norm) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
+          "dflt": true,
           "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
         },
-        "fill": {
-          "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.",
-          "dflt": "none",
+        "cmax": {
+          "description": "Sets the upper bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmin` must be set as well.",
+          "dflt": null,
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "none",
-            "toself"
-          ],
-          "magic_underscores": "fig.update_traces(fill=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "impliedEdits": {
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
         },
-        "fillcolor": {
-          "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
+        "cmid": {
+          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as u/v/w norm. Has no effect when `cauto` is `false`.",
+          "dflt": null,
           "editType": "calc",
-          "valType": "color",
-          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "cmin": {
+          "description": "Sets the lower bound of the color domain. Value should have the same units as u/v/w norm and if set, `cmax` must be set as well.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
         },
         "hoverlabel": {
           "align": {
@@ -67014,36 +56805,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
           "editType": "none",
           "font": {
@@ -67051,12 +56827,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -67067,12 +56838,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -67088,12 +56854,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "role": "object",
             "shadow": {
@@ -67102,24 +56863,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "style": {
               "arrayOk": true,
@@ -67131,12 +56882,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -67150,12 +56896,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "variant": {
               "arrayOk": true,
@@ -67171,12 +56912,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
             "weight": {
               "arrayOk": true,
@@ -67190,14 +56926,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='streamtube'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -67206,12 +56937,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
           "role": "object",
           "showarrow": {
@@ -67219,80 +56945,181 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='scattergeo'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='streamtube'))"
         },
-        "locationmode": {
-          "description": "The library used by the *country names* `locationmode` option is changing in an upcoming version. Country names in existing plots may not work in the new version. Determines the set of locations used to match entries in `locations` to regions on the map. Values *ISO-3*, *USA-states*, *country names* correspond to features on the base map and value *geojson-id* corresponds to features from a custom GeoJSON linked to the `geojson` attribute. *USA-states* accepts both two-letter abbreviations (e.g. *CA*) and full state names (e.g. *California*).",
-          "dflt": "ISO-3",
+        "lighting": {
+          "ambient": {
+            "description": "Ambient light increases overall color visibility but can wash out the image.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "diffuse": {
+            "description": "Represents the extent that incident rays are reflected in a range of angles.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
           "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "ISO-3",
-            "USA-states",
-            "country names",
-            "geojson-id"
-          ],
-          "magic_underscores": "fig.update_traces(locationmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          "facenormalsepsilon": {
+            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-06,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "fresnel": {
+            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
+            "dflt": 0.2,
+            "editType": "calc",
+            "max": 5,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "role": "object",
+          "roughness": {
+            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
+            "dflt": 0.5,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "specular": {
+            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
+            "dflt": 0.05,
+            "editType": "calc",
+            "max": 2,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "vertexnormalsepsilon": {
+            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-12,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='streamtube'))"
         },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+        "lightposition": {
+          "editType": "calc",
+          "role": "object",
+          "x": {
+            "description": "Numeric vector, representing the X coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "y": {
+            "description": "Numeric vector, representing the Y coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "z": {
+            "description": "Numeric vector, representing the Z coordinate for each vertex.",
+            "dflt": 0,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='streamtube'))"
+        },
+        "maxdisplayed": {
+          "description": "The maximum number of displayed segments in a streamtube.",
+          "dflt": 1000,
+          "editType": "calc",
+          "min": 0,
+          "valType": "integer",
+          "magic_underscores": "fig.update_traces(maxdisplayed=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "sizeref": {
+          "description": "The scaling factor for the streamtubes. The default is 1, which avoids two max divergence tubes from touching at adjacent starting positions.",
+          "dflt": 1,
+          "editType": "calc",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(sizeref=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
         },
-        "stream": {
+        "starts": {
           "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
+          "role": "object",
+          "x": {
+            "description": "Sets the x components of the starting position of the streamtubes",
             "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(starts_x=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
+          "y": {
+            "description": "Sets the y components of the starting position of the streamtubes",
             "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(starts_y=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
           },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scattergeo'))"
+          "z": {
+            "description": "Sets the z components of the starting position of the streamtubes",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(starts_z=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+          },
+          "magic_underscores": "fig.update_traces(starts=dict(...), selector=dict(type='streamtube'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='scattergeo'))"
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='streamtube'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='streamtube'))"
       },
       "categories": [
-        "geo",
-        "symbols",
-        "showLegend",
-        "scatter-like"
+        "gl3d",
+        "showLegend"
       ],
       "meta": {
-        "description": "The data visualized as scatter point or lines on a geographic map is provided either by longitude/latitude pairs in `lon` and `lat` respectively or by geographic location IDs or names in `locations`.",
-        "hrName": "scatter_geo"
+        "description": "Use a streamtube trace to visualize flow in a vector field.  Specify a vector field using 6 1D arrays of equal length, 3 position arrays `x`, `y` and `z` and 3 vector component arrays `u`, `v`, and `w`.  By default, the tubes' starting positions will be cut from the vector field's x-z plane at its minimum y value. To specify your own starting position, use attributes `starts.x`, `starts.y` and `starts.z`. The color is encoded by the norm of (u, v, w), and the local radius by the divergence of (u, v, w)."
       },
-      "type": "scattergeo"
+      "type": "streamtube"
     },
-    "choropleth": {
+    "volume": {
       "animatable": false,
       "attributes": {
-        "type": "choropleth",
+        "type": "volume",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -67304,35 +57131,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": false,
-          "editType": "style",
+          "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -67340,7 +57167,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -67350,7 +57177,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -67365,7 +57192,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "role": "object",
             "shadow": {
@@ -67373,13 +57200,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -67390,7 +57217,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -67403,7 +57230,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -67418,7 +57245,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -67431,9 +57258,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='volume'))"
           },
           "role": "object",
           "text": {
@@ -67441,75 +57268,63 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='volume'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
+          "dflt": 1,
+          "editType": "calc",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "z": {
-          "description": "Sets the color values.",
-          "editType": "calc",
+        "x": {
+          "description": "Sets the X coordinates of the vertices on X axis.",
+          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "geojson": {
-          "description": "Sets optional GeoJSON data associated with this trace. If not given, the features on the base map are used. It can be set as a valid GeoJSON object or as a URL string. Note that we only accept GeoJSONs of type *FeatureCollection* or *Feature* with geometries of type *Polygon* or *MultiPolygon*.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(geojson=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "featureidkey": {
-          "description": "Sets the key in GeoJSON features which is used as id to match the items included in the `locations` array. Only has an effect when `geojson` is set. Support nested property, for example *properties.name*.",
-          "dflt": "id",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(featureidkey=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+        "y": {
+          "description": "Sets the Y coordinates of the vertices on Y axis.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "locations": {
-          "description": "Sets the coordinates via location IDs or names. See `locationmode` for more info.",
-          "editType": "calc",
+        "z": {
+          "description": "Sets the Z coordinates of the vertices on Z axis.",
+          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(locations=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "locationssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-          "editType": "none",
-          "valType": "string"
+        "value": {
+          "description": "Sets the 4th dimension (value) of the vertices.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(value=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets the text elements associated with each location.",
+          "description": "Sets the text elements associated with the vertices. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "hovertext": {
           "arrayOk": true,
@@ -67517,16 +57332,11 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -67535,68 +57345,70 @@
             "skip"
           ],
           "flags": [
-            "location",
+            "x",
+            "y",
             "z",
             "text",
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
-          "editType": "none",
+          "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
-          "editType": "none",
+          "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+        },
+        "valuehoverformat": {
+          "description": "Sets the hover text formatting rule for `value` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(valuehoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "geo": {
-          "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on.",
-          "dflt": "geo",
-          "editType": "calc",
+        "scene": {
+          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
+          "dflt": "scene",
+          "editType": "calc+clearAxisTypes",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(geo=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "coloraxis": {
           "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -67604,98 +57416,46 @@
           "editType": "calc",
           "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "marker": {
-          "editType": "calc",
-          "line": {
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "editType": "calc",
-            "role": "object",
-            "width": {
-              "arrayOk": true,
-              "description": "Sets the width (in px) of the lines bounding the marker points.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='choropleth'))"
-          },
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the opacity of the locations.",
-            "dflt": 1,
-            "editType": "style",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "colorbar": {
           "bgcolor": {
             "description": "Sets the color of padded area.",
             "dflt": "rgba(0,0,0,0)",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "bordercolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "borderwidth": {
             "description": "Sets the width (in px) or the border enclosing this color bar.",
             "dflt": 0,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "dtick": {
             "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "colorbars",
+            "editType": "calc",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
-          "editType": "colorbars",
+          "editType": "calc",
           "exponentformat": {
             "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
             "dflt": "B",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "none",
@@ -67706,88 +57466,88 @@
               "B",
               "SI extended"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "labelalias": {
             "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
             "dflt": false,
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "len": {
             "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
             "dflt": 1,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "lenmode": {
             "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
             "dflt": "fraction",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "minexponent": {
             "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
             "dflt": 3,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "nticks": {
             "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
             "dflt": 0,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "orientation": {
             "description": "Sets the orientation of the colorbar.",
             "dflt": "v",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "h",
               "v"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "outlinecolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "outlinewidth": {
             "description": "Sets the width (in px) of the axis line.",
             "dflt": 1,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "role": "object",
           "separatethousands": {
             "description": "If \"true\", even 4-digit integers are separated",
             "dflt": false,
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "showexponent": {
             "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
             "dflt": "all",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "all",
@@ -67795,19 +57555,19 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "showticklabels": {
             "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "showtickprefix": {
             "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
             "dflt": "all",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "all",
@@ -67815,12 +57575,12 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "showticksuffix": {
             "description": "Same as `showtickprefix` but for tick suffixes.",
             "dflt": "all",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "all",
@@ -67828,71 +57588,71 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "thickness": {
             "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
             "dflt": 30,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "thicknessmode": {
             "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
             "dflt": "pixels",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tick0": {
             "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "colorbars",
+            "editType": "calc",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickangle": {
             "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
             "dflt": "auto",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickcolor": {
             "description": "Sets the tick color.",
             "dflt": "#444",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickfont": {
             "color": {
-              "editType": "colorbars",
+              "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "description": "Sets the color bar's tick label font",
-            "editType": "colorbars",
+            "editType": "calc",
             "family": {
               "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "colorbars",
+              "editType": "calc",
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
               "dflt": "none",
-              "editType": "colorbars",
+              "editType": "calc",
               "extras": [
                 "none"
               ],
@@ -67902,37 +57662,37 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "role": "object",
             "shadow": {
               "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
               "dflt": "none",
-              "editType": "colorbars",
+              "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "size": {
-              "editType": "colorbars",
+              "editType": "calc",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -67940,12 +57700,12 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
                 "normal",
@@ -67955,12 +57715,12 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
               "dflt": "normal",
-              "editType": "colorbars",
+              "editType": "calc",
               "extras": [
                 "normal",
                 "bold"
@@ -67968,79 +57728,79 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='volume'))"
           },
           "tickformat": {
             "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
             "dflt": "",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickformatstops": {
             "items": {
               "tickformatstop": {
                 "dtickrange": {
                   "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "colorbars",
+                  "editType": "calc",
                   "items": [
                     {
-                      "editType": "colorbars",
+                      "editType": "calc",
                       "valType": "any"
                     },
                     {
-                      "editType": "colorbars",
+                      "editType": "calc",
                       "valType": "any"
                     }
                   ],
                   "valType": "info_array"
                 },
-                "editType": "colorbars",
+                "editType": "calc",
                 "enabled": {
                   "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
                   "dflt": true,
-                  "editType": "colorbars",
+                  "editType": "calc",
                   "valType": "boolean"
                 },
                 "name": {
                   "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "colorbars",
+                  "editType": "calc",
                   "valType": "string"
                 },
                 "role": "object",
                 "templateitemname": {
                   "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "colorbars",
+                  "editType": "calc",
                   "valType": "string"
                 },
                 "value": {
                   "description": "string - dtickformat for described zoom level, the same as *tickformat*",
                   "dflt": "",
-                  "editType": "colorbars",
+                  "editType": "calc",
                   "valType": "string"
                 }
               }
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='volume'))"
           },
           "ticklabeloverflow": {
             "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "allow",
               "hide past div",
               "hide past domain"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "ticklabelposition": {
             "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
             "dflt": "outside",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "outside",
@@ -68054,29 +57814,29 @@
               "outside bottom",
               "inside bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "ticklabelstep": {
             "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
             "dflt": 1,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "ticklen": {
             "description": "Sets the tick length (in px).",
             "dflt": 5,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickmode": {
             "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "colorbars",
+            "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "valType": "enumerated",
             "values": [
@@ -68084,86 +57844,76 @@
               "linear",
               "array"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickprefix": {
             "description": "Sets a tick label prefix.",
             "dflt": "",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "ticks": {
             "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
             "dflt": "",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "outside",
               "inside",
               ""
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "ticksuffix": {
             "description": "Sets a tick label suffix.",
             "dflt": "",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "ticktext": {
             "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "title": {
-            "editType": "colorbars",
+            "editType": "calc",
             "font": {
               "color": {
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "description": "Sets this color bar's title font.",
-              "editType": "colorbars",
+              "editType": "calc",
               "family": {
                 "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
+                "editType": "calc",
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
                 "dflt": "none",
-                "editType": "colorbars",
+                "editType": "calc",
                 "extras": [
                   "none"
                 ],
@@ -68173,37 +57923,37 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "role": "object",
               "shadow": {
                 "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
                 "dflt": "none",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "size": {
-                "editType": "colorbars",
+                "editType": "calc",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "enumerated",
                 "values": [
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -68211,12 +57961,12 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "valType": "enumerated",
                 "values": [
                   "normal",
@@ -68226,12 +57976,12 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
                 "dflt": "normal",
-                "editType": "colorbars",
+                "editType": "calc",
                 "extras": [
                   "normal",
                   "bold"
@@ -68239,222 +57989,290 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
               },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='volume'))"
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "colorbars",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
                 "right",
                 "top",
                 "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "text": {
               "description": "Sets the title of the color bar.",
-              "editType": "colorbars",
+              "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='volume'))"
           },
           "x": {
             "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "xanchor": {
             "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "left",
               "center",
               "right"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "xpad": {
             "description": "Sets the amount of padding (in px) along the x direction.",
             "dflt": 10,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "xref": {
             "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
             "dflt": "paper",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "y": {
             "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "yanchor": {
             "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "top",
               "middle",
               "bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "ypad": {
             "description": "Sets the amount of padding (in px) along the y direction.",
             "dflt": 10,
-            "editType": "colorbars",
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "yref": {
             "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
             "dflt": "paper",
-            "editType": "colorbars",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='volume'))"
         },
         "autocolorscale": {
           "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "showscale": {
           "description": "Determines whether or not a colorbar is displayed for this trace.",
           "dflt": true,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
+          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
           "dflt": false,
-          "editType": "plot",
+          "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "zauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
+        "zhoverformat": {
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='volume'))"
+        },
+        "cauto": {
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here `value`) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "zmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
+        "cmax": {
+          "description": "Sets the upper bound of the color domain. Value should have the same units as `value` and if set, `cmin` must be set as well.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "zmid": {
-          "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
+        "cmid": {
+          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as `value`. Has no effect when `cauto` is `false`.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "zmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
+        "cmin": {
+          "description": "Sets the lower bound of the color domain. Value should have the same units as `value` and if set, `cmax` must be set as well.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+        "caps": {
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "selected": {
-          "editType": "plot",
-          "marker": {
-            "editType": "plot",
-            "opacity": {
-              "description": "Sets the marker opacity of selected points.",
+          "role": "object",
+          "x": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
               "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(caps_x_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='choropleth'))"
+            "show": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the x `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(caps_x_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "magic_underscores": "fig.update_traces(caps_x=dict(...), selector=dict(type='volume'))"
           },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='choropleth'))"
-        },
-        "unselected": {
-          "editType": "plot",
-          "marker": {
-            "editType": "plot",
-            "opacity": {
-              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
+          "y": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
               "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+              "magic_underscores": "fig.update_traces(caps_y_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='choropleth'))"
+            "show": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the y `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(caps_y_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "magic_underscores": "fig.update_traces(caps_y=dict(...), selector=dict(type='volume'))"
+          },
+          "z": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(caps_z_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "role": "object",
+            "show": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the z `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(caps_z_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "magic_underscores": "fig.update_traces(caps_z=dict(...), selector=dict(type='volume'))"
           },
+          "magic_underscores": "fig.update_traces(caps=dict(...), selector=dict(type='volume'))"
+        },
+        "contour": {
+          "color": {
+            "description": "Sets the color of the contour lines.",
+            "dflt": "#444",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(contour_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "editType": "calc",
           "role": "object",
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='choropleth'))"
+          "show": {
+            "description": "Sets whether or not dynamic contours are shown on hover",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(contour_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "width": {
+            "description": "Sets the width of the contour lines.",
+            "dflt": 2,
+            "editType": "calc",
+            "max": 16,
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(contour_width=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "magic_underscores": "fig.update_traces(contour=dict(...), selector=dict(type='volume'))"
+        },
+        "flatshading": {
+          "description": "Determines whether or not normal smoothing is applied to the meshes, creating meshes with an angular, low-poly look via flat reflections.",
+          "dflt": true,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(flatshading=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
         "hoverlabel": {
           "align": {
@@ -68468,36 +58286,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "editType": "none",
           "font": {
@@ -68505,12 +58308,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -68521,12 +58319,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -68542,12 +58335,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "role": "object",
             "shadow": {
@@ -68556,24 +58344,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "style": {
               "arrayOk": true,
@@ -68585,12 +58363,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -68604,12 +58377,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "variant": {
               "arrayOk": true,
@@ -68625,12 +58393,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
             "weight": {
               "arrayOk": true,
@@ -68644,14 +58407,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='volume'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='volume'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -68660,91 +58418,326 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "role": "object",
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='volume'))"
+        },
+        "isomax": {
+          "description": "Sets the maximum boundary for iso-surface plot.",
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(isomax=&lt;VALUE&gt;, selector=dict(type='volume'))"
+        },
+        "isomin": {
+          "description": "Sets the minimum boundary for iso-surface plot.",
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(isomin=&lt;VALUE&gt;, selector=dict(type='volume'))"
+        },
+        "lighting": {
+          "ambient": {
+            "description": "Ambient light increases overall color visibility but can wash out the image.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "diffuse": {
+            "description": "Represents the extent that incident rays are reflected in a range of angles.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "editType": "calc",
+          "facenormalsepsilon": {
+            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 0,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "fresnel": {
+            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
+            "dflt": 0.2,
+            "editType": "calc",
+            "max": 5,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "role": "object",
+          "roughness": {
+            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
+            "dflt": 0.5,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "specular": {
+            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
+            "dflt": 0.05,
+            "editType": "calc",
+            "max": 2,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "vertexnormalsepsilon": {
+            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-12,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='volume'))"
+        },
+        "lightposition": {
+          "editType": "calc",
+          "role": "object",
+          "x": {
+            "description": "Numeric vector, representing the X coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "y": {
+            "description": "Numeric vector, representing the Y coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "z": {
+            "description": "Numeric vector, representing the Z coordinate for each vertex.",
+            "dflt": 0,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='volume'))"
+        },
+        "opacityscale": {
+          "description": "Sets the opacityscale. The opacityscale must be an array containing arrays mapping a normalized value to an opacity value. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 1], [0.5, 0.2], [1, 1]]` means that higher/lower values would have higher opacity values and those in the middle would be more transparent Alternatively, `opacityscale` may be a palette name string of the following list: 'min', 'max', 'extremes' and 'uniform'. The default is 'uniform'.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(opacityscale=&lt;VALUE&gt;, selector=dict(type='volume'))"
+        },
+        "slices": {
+          "editType": "calc",
+          "role": "object",
+          "x": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(slices_x_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "locations": {
+              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis x except start and end.",
+              "dflt": [],
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(slices_x_locations=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "role": "object",
+            "show": {
+              "description": "Determines whether or not slice planes about the x dimension are drawn.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(slices_x_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "magic_underscores": "fig.update_traces(slices_x=dict(...), selector=dict(type='volume'))"
+          },
+          "y": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(slices_y_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "locations": {
+              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis y except start and end.",
+              "dflt": [],
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(slices_y_locations=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "role": "object",
+            "show": {
+              "description": "Determines whether or not slice planes about the y dimension are drawn.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(slices_y_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "magic_underscores": "fig.update_traces(slices_y=dict(...), selector=dict(type='volume'))"
+          },
+          "z": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(slices_z_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "locations": {
+              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis z except start and end.",
+              "dflt": [],
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(slices_z_locations=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "role": "object",
+            "show": {
+              "description": "Determines whether or not slice planes about the z dimension are drawn.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(slices_z_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+            },
+            "magic_underscores": "fig.update_traces(slices_z=dict(...), selector=dict(type='volume'))"
+          },
+          "magic_underscores": "fig.update_traces(slices=dict(...), selector=dict(type='volume'))"
+        },
+        "spaceframe": {
+          "editType": "calc",
+          "fill": {
+            "description": "Sets the fill ratio of the `spaceframe` elements. The default fill value is 1 meaning that they are entirely shaded. Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+            "dflt": 1,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(spaceframe_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "role": "object",
+          "show": {
+            "description": "Displays/hides tetrahedron shapes between minimum and maximum iso-values. Often useful when either caps or surfaces are disabled or filled with values less than 1.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(spaceframe_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "magic_underscores": "fig.update_traces(spaceframe=dict(...), selector=dict(type='volume'))"
+        },
+        "surface": {
+          "count": {
+            "description": "Sets the number of iso-surfaces between minimum and maximum iso-values. By default this value is 2 meaning that only minimum and maximum surfaces would be drawn.",
+            "dflt": 2,
+            "editType": "calc",
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(surface_count=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+          "editType": "calc",
+          "fill": {
+            "description": "Sets the fill ratio of the iso-surface. The default fill value of the surface is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+            "dflt": 1,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(surface_fill=&lt;VALUE&gt;, selector=dict(type='volume'))"
+          },
+          "pattern": {
+            "description": "Sets the surface pattern of the iso-surface 3-D sections. The default pattern of the surface is `all` meaning that the rest of surface elements would be shaded. The check options (either 1 or 2) could be used to draw half of the squares on the surface. Using various combinations of capital `A`, `B`, `C`, `D` and `E` may also be used to reduce the number of triangles on the iso-surfaces and creating other patterns of interest.",
+            "dflt": "all",
+            "editType": "calc",
+            "extras": [
+              "all",
+              "odd",
+              "even"
+            ],
+            "flags": [
+              "A",
+              "B",
+              "C",
+              "D",
+              "E"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(surface_pattern=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
           "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+          "show": {
+            "description": "Hides/displays surfaces between minimum and maximum iso-values.",
             "dflt": true,
-            "editType": "none",
+            "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+            "magic_underscores": "fig.update_traces(surface_show=&lt;VALUE&gt;, selector=dict(type='volume'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='choropleth'))"
-        },
-        "locationmode": {
-          "description": "The library used by the *country names* `locationmode` option is changing in an upcoming version. Country names in existing plots may not work in the new version. Determines the set of locations used to match entries in `locations` to regions on the map. Values *ISO-3*, *USA-states*, *country names* correspond to features on the base map and value *geojson-id* corresponds to features from a custom GeoJSON linked to the `geojson` attribute. *USA-states* accepts both two-letter abbreviations (e.g. *CA*) and full state names (e.g. *California*).",
-          "dflt": "ISO-3",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "ISO-3",
-            "USA-states",
-            "country names",
-            "geojson-id"
-          ],
-          "magic_underscores": "fig.update_traces(locationmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(surface=dict(...), selector=dict(type='volume'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='choropleth'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='volume'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='choropleth'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='volume'))"
       },
       "categories": [
-        "geo",
-        "noOpacity",
+        "gl3d",
         "showLegend"
       ],
       "meta": {
-        "description": "The data that describes the choropleth value-to-color mapping is set in `z`. The geographic locations corresponding to each value in `z` are set in `locations`."
+        "description": "Draws volume trace between iso-min and iso-max values with coordinates given by four 1-dimensional arrays containing the `value`, `x`, `y` and `z` of every vertex of a uniform or non-uniform 3-D grid. Horizontal or vertical slices, caps as well as spaceframe between iso-min and iso-max values could also be drawn using this trace."
       },
-      "type": "choropleth"
+      "type": "volume"
     },
-    "scattermap": {
+    "isosurface": {
       "animatable": false,
       "attributes": {
-        "type": "scattermap",
+        "type": "isosurface",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -68756,35 +58749,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": true,
-          "editType": "style",
+          "dflt": false,
+          "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -68792,7 +58785,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -68802,7 +58795,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -68817,7 +58810,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "role": "object",
             "shadow": {
@@ -68825,13 +58818,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -68842,7 +58835,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -68855,7 +58848,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -68870,7 +58863,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -68883,9 +58876,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='isosurface'))"
           },
           "role": "object",
           "text": {
@@ -68893,217 +58886,75 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='isosurface'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "opacity": {
-          "description": "Sets the opacity of the trace.",
+          "description": "Sets the opacity of the surface. Please note that in the case of using high `opacity` values for example a value greater than or equal to 0.5 on two surfaces (and 0.25 with four surfaces), an overlay of multiple transparent surfaces may not perfectly be sorted in depth by the webgl API. This behavior may be improved in the near future and is subject to change.",
           "dflt": 1,
-          "editType": "style",
+          "editType": "calc",
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "mode": {
-          "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover.",
-          "dflt": "markers",
-          "editType": "calc",
-          "extras": [
-            "none"
-          ],
-          "flags": [
-            "lines",
-            "markers",
-            "text"
-          ],
-          "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "lat": {
-          "description": "Sets the latitude coordinates (in degrees North).",
-          "editType": "calc",
+        "x": {
+          "description": "Sets the X coordinates of the vertices on X axis.",
+          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "latsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lat`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "lon": {
-          "description": "Sets the longitude coordinates (in degrees East).",
-          "editType": "calc",
+        "y": {
+          "description": "Sets the Y coordinates of the vertices on Y axis.",
+          "editType": "calc+clearAxisTypes",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "lonsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lon`.",
-          "editType": "none",
-          "valType": "string"
+        "z": {
+          "description": "Sets the Z coordinates of the vertices on Z axis.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "cluster": {
-          "color": {
-            "arrayOk": true,
-            "description": "Sets the color for each cluster step.",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(cluster_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "editType": "calc",
-          "enabled": {
-            "description": "Determines whether clustering is enabled or disabled.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(cluster_enabled=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "maxzoom": {
-            "description": "Sets the maximum zoom level. At zoom levels equal to or greater than this, points will never be clustered.",
-            "dflt": 24,
-            "editType": "calc",
-            "max": 24,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_maxzoom=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the marker opacity.",
-            "dflt": 1,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "size": {
-            "arrayOk": true,
-            "description": "Sets the size for each cluster step.",
-            "dflt": 20,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "step": {
-            "arrayOk": true,
-            "description": "Sets how many points it takes to create a cluster or advance to the next cluster step. Use this in conjunction with arrays for `size` and / or `color`. If an integer, steps start at multiples of this number. If an array, each step extends from the given value until one less than the next value.",
-            "dflt": -1,
-            "editType": "calc",
-            "min": -1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_step=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "stepsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `step`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "magic_underscores": "fig.update_traces(cluster=dict(...), selector=dict(type='scattermap'))"
+        "value": {
+          "description": "Sets the 4th dimension (value) of the vertices.",
+          "editType": "calc+clearAxisTypes",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(value=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
-          "dflt": "",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "textposition": {
-          "arrayOk": false,
-          "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
-          "dflt": "middle center",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "top left",
-            "top center",
-            "top right",
-            "middle left",
-            "middle center",
-            "middle right",
-            "bottom left",
-            "bottom center",
-            "bottom right"
-          ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "texttemplate": {
-          "arrayOk": true,
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `lat`, `lon` and `text`.",
+          "description": "Sets the text elements associated with the vertices. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "texttemplatefallback": {
-          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
-          "dflt": "-",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "hovertext": {
           "arrayOk": true,
-          "description": "Sets hover text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "description": "Same as `text`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -69112,18 +58963,14 @@
             "skip"
           ],
           "flags": [
-            "lon",
-            "lat",
+            "x",
+            "y",
+            "z",
             "text",
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "hovertemplate": {
           "arrayOk": true,
@@ -69131,360 +58978,547 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+        "xhoverformat": {
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "yhoverformat": {
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(yhoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "valuehoverformat": {
+          "description": "Sets the hover text formatting rule for `value` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format.By default the values are formatted using generic number format.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(valuehoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+        "scene": {
+          "description": "Sets a reference between this trace's 3D coordinate system and a 3D scene. If *scene* (the default value), the (x,y,z) coordinates refer to `layout.scene`. If *scene2*, the (x,y,z) coordinates refer to `layout.scene2`, and so on.",
+          "dflt": "scene",
+          "editType": "calc+clearAxisTypes",
+          "valType": "subplotid",
+          "magic_underscores": "fig.update_traces(scene=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "subplot": {
-          "description": "Sets a reference between this trace's data coordinates and a map subplot. If *map* (the default value), the data refer to `layout.map`. If *map2*, the data refer to `layout.map2`, and so on.",
-          "dflt": "map",
+        "coloraxis": {
+          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+          "dflt": null,
           "editType": "calc",
+          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "marker": {
-          "allowoverlap": {
-            "description": "Flag to draw all symbols, even if they overlap.",
+        "colorbar": {
+          "bgcolor": {
+            "description": "Sets the color of padded area.",
+            "dflt": "rgba(0,0,0,0)",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "bordercolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "borderwidth": {
+            "description": "Sets the width (in px) or the border enclosing this color bar.",
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "dtick": {
+            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+            "editType": "calc",
+            "impliedEdits": {
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "editType": "calc",
+          "exponentformat": {
+            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+            "dflt": "B",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "none",
+              "e",
+              "E",
+              "power",
+              "SI",
+              "B",
+              "SI extended"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "labelalias": {
+            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
             "dflt": false,
             "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_allowoverlap=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "angle": {
-            "arrayOk": true,
-            "description": "Sets the marker orientation from true North, in degrees clockwise. When using the *auto* default, no rotation would be applied in perspective views which is different from using a zero angle.",
-            "dflt": "auto",
+          "len": {
+            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+            "dflt": 1,
             "editType": "calc",
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
+          "lenmode": {
+            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+            "dflt": "fraction",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "autocolorscale": {
-            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+          "minexponent": {
+            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+            "dflt": 3,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "nticks": {
+            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "orientation": {
+            "description": "Sets the orientation of the colorbar.",
+            "dflt": "v",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "h",
+              "v"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "outlinecolor": {
+            "description": "Sets the axis line color.",
+            "dflt": "#444",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "outlinewidth": {
+            "description": "Sets the width (in px) of the axis line.",
+            "dflt": 1,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "role": "object",
+          "separatethousands": {
+            "description": "If \"true\", even 4-digit integers are separated",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "showexponent": {
+            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+            "dflt": "all",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "showticklabels": {
+            "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
             "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "showtickprefix": {
+            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+            "dflt": "all",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "cauto": {
-            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
-            "dflt": true,
+          "showticksuffix": {
+            "description": "Same as `showtickprefix` but for tick suffixes.",
+            "dflt": "all",
             "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "enumerated",
+            "values": [
+              "all",
+              "first",
+              "last",
+              "none"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "cmax": {
-            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
-            "dflt": null,
+          "thickness": {
+            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+            "dflt": 30,
             "editType": "calc",
-            "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "cmid": {
-            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
-            "dflt": null,
+          "thicknessmode": {
+            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+            "dflt": "pixels",
             "editType": "calc",
-            "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "enumerated",
+            "values": [
+              "fraction",
+              "pixels"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "cmin": {
-            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
-            "dflt": null,
+          "tick0": {
+            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
             "editType": "calc",
             "impliedEdits": {
-              "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "tickmode": "linear",
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "any",
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "color": {
-            "arrayOk": true,
-            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
+          "tickangle": {
+            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+            "dflt": "auto",
             "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "angle",
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "coloraxis": {
-            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-            "dflt": null,
+          "tickcolor": {
+            "description": "Sets the tick color.",
+            "dflt": "#444",
             "editType": "calc",
-            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
-            "valType": "subplotid",
-            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "colorbar": {
-            "bgcolor": {
-              "description": "Sets the color of padded area.",
-              "dflt": "rgba(0,0,0,0)",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "bordercolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
+          "tickfont": {
+            "color": {
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "borderwidth": {
-              "description": "Sets the width (in px) or the border enclosing this color bar.",
-              "dflt": 0,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "dtick": {
-              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-              "editType": "calc",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
+            "description": "Sets the color bar's tick label font",
             "editType": "calc",
-            "exponentformat": {
-              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-              "dflt": "B",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "none",
-                "e",
-                "E",
-                "power",
-                "SI",
-                "B",
-                "SI extended"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "labelalias": {
-              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "len": {
-              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-              "dflt": 1,
+            "family": {
+              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
               "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "noBlank": true,
+              "strict": true,
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "lenmode": {
-              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-              "dflt": "fraction",
+            "lineposition": {
+              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+              "dflt": "none",
               "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
+              "extras": [
+                "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "minexponent": {
-              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-              "dflt": 3,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "nticks": {
-              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-              "dflt": 0,
-              "editType": "calc",
-              "min": 0,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "orientation": {
-              "description": "Sets the orientation of the colorbar.",
-              "dflt": "v",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "h",
-                "v"
+              "flags": [
+                "under",
+                "over",
+                "through"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "valType": "flaglist",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "outlinecolor": {
-              "description": "Sets the axis line color.",
-              "dflt": "#444",
+            "role": "object",
+            "shadow": {
+              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+              "dflt": "none",
               "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "outlinewidth": {
-              "description": "Sets the width (in px) of the axis line.",
-              "dflt": 1,
+            "size": {
               "editType": "calc",
-              "min": 0,
+              "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "role": "object",
-            "separatethousands": {
-              "description": "If \"true\", even 4-digit integers are separated",
-              "dflt": false,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "showexponent": {
-              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-              "dflt": "all",
+            "style": {
+              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+              "dflt": "normal",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "italic"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "showticklabels": {
-              "description": "Determines whether or not the tick labels are drawn.",
-              "dflt": true,
-              "editType": "calc",
-              "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "showtickprefix": {
-              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-              "dflt": "all",
+            "textcase": {
+              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+              "dflt": "normal",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "word caps",
+                "upper",
+                "lower"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "showticksuffix": {
-              "description": "Same as `showtickprefix` but for tick suffixes.",
-              "dflt": "all",
+            "variant": {
+              "description": "Sets the variant of the font.",
+              "dflt": "normal",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "all",
-                "first",
-                "last",
-                "none"
+                "normal",
+                "small-caps",
+                "all-small-caps",
+                "all-petite-caps",
+                "petite-caps",
+                "unicase"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "thickness": {
-              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-              "dflt": 30,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "thicknessmode": {
-              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-              "dflt": "pixels",
+            "weight": {
+              "description": "Sets the weight (or boldness) of the font.",
+              "dflt": "normal",
               "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "fraction",
-                "pixels"
+              "extras": [
+                "normal",
+                "bold"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "tick0": {
-              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-              "editType": "calc",
-              "impliedEdits": {
-                "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-              },
-              "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "max": 1000,
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "tickangle": {
-              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-              "dflt": "auto",
-              "editType": "calc",
-              "valType": "angle",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='isosurface'))"
+          },
+          "tickformat": {
+            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+            "dflt": "",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "tickformatstops": {
+            "items": {
+              "tickformatstop": {
+                "dtickrange": {
+                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                  "editType": "calc",
+                  "items": [
+                    {
+                      "editType": "calc",
+                      "valType": "any"
+                    },
+                    {
+                      "editType": "calc",
+                      "valType": "any"
+                    }
+                  ],
+                  "valType": "info_array"
+                },
+                "editType": "calc",
+                "enabled": {
+                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                  "dflt": true,
+                  "editType": "calc",
+                  "valType": "boolean"
+                },
+                "name": {
+                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                  "editType": "calc",
+                  "valType": "string"
+                },
+                "role": "object",
+                "templateitemname": {
+                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                  "editType": "calc",
+                  "valType": "string"
+                },
+                "value": {
+                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                  "dflt": "",
+                  "editType": "calc",
+                  "valType": "string"
+                }
+              }
             },
-            "tickcolor": {
-              "description": "Sets the tick color.",
-              "dflt": "#444",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "role": "object",
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='isosurface'))"
+          },
+          "ticklabeloverflow": {
+            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "allow",
+              "hide past div",
+              "hide past domain"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "ticklabelposition": {
+            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+            "dflt": "outside",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              "outside top",
+              "inside top",
+              "outside left",
+              "inside left",
+              "outside right",
+              "inside right",
+              "outside bottom",
+              "inside bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "ticklabelstep": {
+            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+            "dflt": 1,
+            "editType": "calc",
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "ticklen": {
+            "description": "Sets the tick length (in px).",
+            "dflt": 5,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "tickmode": {
+            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "tickfont": {
+            "valType": "enumerated",
+            "values": [
+              "auto",
+              "linear",
+              "array"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "tickprefix": {
+            "description": "Sets a tick label prefix.",
+            "dflt": "",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "ticks": {
+            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+            "dflt": "",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "outside",
+              "inside",
+              ""
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "ticksuffix": {
+            "description": "Sets a tick label suffix.",
+            "dflt": "",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "ticktext": {
+            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "tickvals": {
+            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+            "editType": "calc",
+            "valType": "data_array",
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "tickwidth": {
+            "description": "Sets the tick width (in px).",
+            "dflt": 1,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "title": {
+            "editType": "calc",
+            "font": {
               "color": {
                 "editType": "calc",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
-              "description": "Sets the color bar's tick label font",
+              "description": "Sets this color bar's title font.",
               "editType": "calc",
               "family": {
                 "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
@@ -69492,7 +59526,7 @@
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -69507,7 +59541,7 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
               "role": "object",
               "shadow": {
@@ -69515,13 +59549,13 @@
                 "dflt": "none",
                 "editType": "calc",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
               "size": {
                 "editType": "calc",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -69532,7 +59566,7 @@
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -69545,7 +59579,7 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
@@ -69560,7 +59594,7 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
@@ -69573,642 +59607,290 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-              },
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='scattermap'))"
-            },
-            "tickformat": {
-              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "tickformatstops": {
-              "items": {
-                "tickformatstop": {
-                  "dtickrange": {
-                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                    "editType": "calc",
-                    "items": [
-                      {
-                        "editType": "calc",
-                        "valType": "any"
-                      },
-                      {
-                        "editType": "calc",
-                        "valType": "any"
-                      }
-                    ],
-                    "valType": "info_array"
-                  },
-                  "editType": "calc",
-                  "enabled": {
-                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                    "dflt": true,
-                    "editType": "calc",
-                    "valType": "boolean"
-                  },
-                  "name": {
-                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                    "editType": "calc",
-                    "valType": "string"
-                  },
-                  "role": "object",
-                  "templateitemname": {
-                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                    "editType": "calc",
-                    "valType": "string"
-                  },
-                  "value": {
-                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                    "dflt": "",
-                    "editType": "calc",
-                    "valType": "string"
-                  }
-                }
-              },
-              "role": "object",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='scattermap'))"
-            },
-            "ticklabeloverflow": {
-              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "allow",
-                "hide past div",
-                "hide past domain"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ticklabelposition": {
-              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-              "dflt": "outside",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                "outside top",
-                "inside top",
-                "outside left",
-                "inside left",
-                "outside right",
-                "inside right",
-                "outside bottom",
-                "inside bottom"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ticklabelstep": {
-              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ticklen": {
-              "description": "Sets the tick length (in px).",
-              "dflt": 5,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "tickmode": {
-              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-              "editType": "calc",
-              "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-              },
-              "valType": "enumerated",
-              "values": [
-                "auto",
-                "linear",
-                "array"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "tickprefix": {
-              "description": "Sets a tick label prefix.",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ticks": {
-              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "outside",
-                "inside",
-                ""
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ticksuffix": {
-              "description": "Sets a tick label suffix.",
-              "dflt": "",
-              "editType": "calc",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ticktext": {
-              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickvals": {
-              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-              "editType": "calc",
-              "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
-            "tickwidth": {
-              "description": "Sets the tick width (in px).",
-              "dflt": 1,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "title": {
-              "editType": "calc",
-              "font": {
-                "color": {
-                  "editType": "calc",
-                  "valType": "color",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "description": "Sets this color bar's title font.",
-                "editType": "calc",
-                "family": {
-                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                  "editType": "calc",
-                  "noBlank": true,
-                  "strict": true,
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "lineposition": {
-                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                  "dflt": "none",
-                  "editType": "calc",
-                  "extras": [
-                    "none"
-                  ],
-                  "flags": [
-                    "under",
-                    "over",
-                    "through"
-                  ],
-                  "valType": "flaglist",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "role": "object",
-                "shadow": {
-                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                  "dflt": "none",
-                  "editType": "calc",
-                  "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "size": {
-                  "editType": "calc",
-                  "min": 1,
-                  "valType": "number",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "style": {
-                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "italic"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "textcase": {
-                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "word caps",
-                    "upper",
-                    "lower"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "variant": {
-                  "description": "Sets the variant of the font.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "valType": "enumerated",
-                  "values": [
-                    "normal",
-                    "small-caps",
-                    "all-small-caps",
-                    "all-petite-caps",
-                    "petite-caps",
-                    "unicase"
-                  ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "weight": {
-                  "description": "Sets the weight (or boldness) of the font.",
-                  "dflt": "normal",
-                  "editType": "calc",
-                  "extras": [
-                    "normal",
-                    "bold"
-                  ],
-                  "max": 1000,
-                  "min": 1,
-                  "valType": "integer",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-                },
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='scattermap'))"
-              },
-              "role": "object",
-              "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-                "editType": "calc",
-                "valType": "enumerated",
-                "values": [
-                  "right",
-                  "top",
-                  "bottom"
-                ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-              },
-              "text": {
-                "description": "Sets the title of the color bar.",
-                "editType": "calc",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
               },
-              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='scattermap'))"
-            },
-            "x": {
-              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "xanchor": {
-              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "left",
-                "center",
-                "right"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "xpad": {
-              "description": "Sets the amount of padding (in px) along the x direction.",
-              "dflt": 10,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "xref": {
-              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-              "dflt": "paper",
-              "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "y": {
-              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-              "editType": "calc",
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='isosurface'))"
             },
-            "yanchor": {
-              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+            "role": "object",
+            "side": {
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "calc",
               "valType": "enumerated",
               "values": [
+                "right",
                 "top",
-                "middle",
                 "bottom"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "ypad": {
-              "description": "Sets the amount of padding (in px) along the y direction.",
-              "dflt": 10,
-              "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "yref": {
-              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-              "dflt": "paper",
+            "text": {
+              "description": "Sets the title of the color bar.",
               "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "container",
-                "paper"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattermap'))"
-          },
-          "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-            "dflt": null,
-            "editType": "calc",
-            "impliedEdits": {
-              "autocolorscale": false,
-              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "valType": "colorscale",
-            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='isosurface'))"
           },
-          "editType": "calc",
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the marker opacity.",
+          "x": {
+            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
             "editType": "calc",
-            "max": 1,
-            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "reversescale": {
-            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "role": "object",
-          "showscale": {
-            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "size": {
-            "arrayOk": true,
-            "description": "Sets the marker size (in px).",
-            "dflt": 6,
+          "xanchor": {
+            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
             "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "enumerated",
+            "values": [
+              "left",
+              "center",
+              "right"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "sizemin": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.",
-            "dflt": 0,
+          "xpad": {
+            "description": "Sets the amount of padding (in px) along the x direction.",
+            "dflt": 10,
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizemin=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "sizemode": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.",
-            "dflt": "diameter",
+          "xref": {
+            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+            "dflt": "paper",
             "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "diameter",
-              "area"
+              "container",
+              "paper"
             ],
-            "magic_underscores": "fig.update_traces(marker_sizemode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "sizeref": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.",
-            "dflt": 1,
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "symbol": {
-            "arrayOk": true,
-            "description": "Sets the marker symbol. Full list: https://www.mapbox.com/maki-icons/ Note that the array `marker.color` and `marker.size` are only available for *circle* symbols.",
-            "dflt": "circle",
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattermap'))"
-        },
-        "line": {
-          "color": {
-            "description": "Sets the line color.",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "editType": "calc",
-          "role": "object",
-          "width": {
-            "description": "Sets the line width (in px).",
-            "dflt": 2,
+          "y": {
+            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
             "editType": "calc",
-            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='scattermap'))"
-        },
-        "textfont": {
-          "color": {
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "description": "Sets the icon text font (color=map.layer.paint.text-color, size=map.layer.layout.text-size). Has an effect only when `type` is set to *symbol*.",
-          "editType": "calc",
-          "family": {
-            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "dflt": "Open Sans Regular, Arial Unicode MS Regular",
+          "yanchor": {
+            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
             "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "role": "object",
-          "size": {
+            "valType": "enumerated",
+            "values": [
+              "top",
+              "middle",
+              "bottom"
+            ],
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "ypad": {
+            "description": "Sets the amount of padding (in px) along the y direction.",
+            "dflt": 10,
             "editType": "calc",
-            "min": 1,
+            "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "style": {
-            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-            "dflt": "normal",
+          "yref": {
+            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+            "dflt": "paper",
             "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "normal",
-              "italic"
+              "container",
+              "paper"
             ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "weight": {
-            "description": "Sets the weight (or boldness) of the font.",
-            "dflt": "normal",
-            "editType": "calc",
-            "extras": [
-              "normal",
-              "bold"
-            ],
-            "max": 1000,
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='isosurface'))"
+        },
+        "autocolorscale": {
+          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+          "dflt": true,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattermap'))"
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "selectedpoints": {
-          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+        "colorscale": {
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "dflt": null,
           "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "impliedEdits": {
+            "autocolorscale": false,
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "valType": "colorscale",
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
-        "selected": {
+        "showscale": {
+          "description": "Determines whether or not a colorbar is displayed for this trace.",
+          "dflt": true,
           "editType": "calc",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of selected points.",
-              "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "reversescale": {
+          "description": "Reverses the color mapping if true. If true, `cmin` will correspond to the last color in the array and `cmax` will correspond to the first color.",
+          "dflt": false,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "zhoverformat": {
+          "description": "Sets the hover text formatting rule for `z` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `zaxis.hoverformat`.",
+          "dflt": "",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(zhoverformat=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "cauto": {
+          "description": "Determines whether or not the color domain is computed with respect to the input data (here `value`) or the bounds set in `cmin` and `cmax` Defaults to `false` when `cmin` and `cmax` are set by the user.",
+          "dflt": true,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(cauto=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "cmax": {
+          "description": "Sets the upper bound of the color domain. Value should have the same units as `value` and if set, `cmin` must be set as well.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmax=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "cmid": {
+          "description": "Sets the mid-point of the color domain by scaling `cmin` and/or `cmax` to be equidistant to this point. Value should have the same units as `value`. Has no effect when `cauto` is `false`.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "magic_underscores": "fig.update_traces(cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmid=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "cmin": {
+          "description": "Sets the lower bound of the color domain. Value should have the same units as `value` and if set, `cmax` must be set as well.",
+          "dflt": null,
+          "editType": "calc",
+          "impliedEdits": {
+            "cauto": false,
+            "magic_underscores": "fig.update_traces(cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(cmin=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "caps": {
+          "editType": "calc",
+          "role": "object",
+          "x": {
             "editType": "calc",
-            "opacity": {
-              "description": "Sets the marker opacity of selected points.",
+            "fill": {
+              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
               "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(caps_x_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "role": "object",
-            "size": {
-              "description": "Sets the marker size of selected points.",
+            "show": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the x `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(caps_x_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "magic_underscores": "fig.update_traces(caps_x=dict(...), selector=dict(type='isosurface'))"
+          },
+          "y": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
               "editType": "calc",
+              "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(caps_y_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='scattermap'))"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='scattermap'))"
-        },
-        "unselected": {
-          "editType": "calc",
-          "marker": {
-            "color": {
-              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
+            "role": "object",
+            "show": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the y `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": true,
               "editType": "calc",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(caps_y_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
+            "magic_underscores": "fig.update_traces(caps_y=dict(...), selector=dict(type='isosurface'))"
+          },
+          "z": {
             "editType": "calc",
-            "opacity": {
-              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
+            "fill": {
+              "description": "Sets the fill ratio of the `caps`. The default fill value of the `caps` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
               "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(caps_z_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "role": "object",
-            "size": {
-              "description": "Sets the marker size of unselected points, applied only when a selection exists.",
+            "show": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the z `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": true,
               "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(caps_z_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(caps_z=dict(...), selector=dict(type='isosurface'))"
           },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(caps=dict(...), selector=dict(type='isosurface'))"
         },
-        "below": {
-          "description": "Determines if this scattermap trace's layers are to be inserted before the layer with the specified ID. By default, scattermap layers are inserted above all the base layers. To place the scattermap layers above every other layer, set `below` to *''*.",
+        "contour": {
+          "color": {
+            "description": "Sets the color of the contour lines.",
+            "dflt": "#444",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(contour_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
           "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "role": "object",
+          "show": {
+            "description": "Sets whether or not dynamic contours are shown on hover",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(contour_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "width": {
+            "description": "Sets the width of the contour lines.",
+            "dflt": 2,
+            "editType": "calc",
+            "max": 16,
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(contour_width=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "magic_underscores": "fig.update_traces(contour=dict(...), selector=dict(type='isosurface'))"
         },
-        "connectgaps": {
-          "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.",
-          "dflt": false,
+        "flatshading": {
+          "description": "Determines whether or not normal smoothing is applied to the meshes, creating meshes with an angular, low-poly look via flat reflections.",
+          "dflt": true,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "fill": {
-          "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.",
-          "dflt": "none",
-          "editType": "calc",
-          "valType": "enumerated",
-          "values": [
-            "none",
-            "toself"
-          ],
-          "magic_underscores": "fig.update_traces(fill=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-        },
-        "fillcolor": {
-          "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
-          "editType": "calc",
-          "valType": "color",
-          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(flatshading=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
         },
         "hoverlabel": {
           "align": {
@@ -70222,36 +59904,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
           "editType": "none",
           "font": {
@@ -70259,12 +59926,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -70275,12 +59937,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -70296,12 +59953,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "role": "object",
             "shadow": {
@@ -70310,24 +59962,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "style": {
               "arrayOk": true,
@@ -70339,12 +59981,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -70358,12 +59995,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "variant": {
               "arrayOk": true,
@@ -70379,12 +60011,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
             "weight": {
               "arrayOk": true,
@@ -70398,97 +60025,331 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='isosurface'))"
+          },
+          "namelength": {
+            "arrayOk": true,
+            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
+            "dflt": 15,
+            "editType": "none",
+            "min": -1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "role": "object",
+          "showarrow": {
+            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
+            "dflt": true,
+            "editType": "none",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='isosurface'))"
+        },
+        "isomax": {
+          "description": "Sets the maximum boundary for iso-surface plot.",
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(isomax=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "isomin": {
+          "description": "Sets the minimum boundary for iso-surface plot.",
+          "editType": "calc",
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(isomin=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "lighting": {
+          "ambient": {
+            "description": "Ambient light increases overall color visibility but can wash out the image.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_ambient=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "diffuse": {
+            "description": "Represents the extent that incident rays are reflected in a range of angles.",
+            "dflt": 0.8,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_diffuse=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "editType": "calc",
+          "facenormalsepsilon": {
+            "description": "Epsilon for face normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 0,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_facenormalsepsilon=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "fresnel": {
+            "description": "Represents the reflectance as a dependency of the viewing angle; e.g. paper is reflective when viewing it from the edge of the paper (almost 90 degrees), causing shine.",
+            "dflt": 0.2,
+            "editType": "calc",
+            "max": 5,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_fresnel=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "role": "object",
+          "roughness": {
+            "description": "Alters specular reflection; the rougher the surface, the wider and less contrasty the shine.",
+            "dflt": 0.5,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_roughness=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "specular": {
+            "description": "Represents the level that incident rays are reflected in a single direction, causing shine.",
+            "dflt": 0.05,
+            "editType": "calc",
+            "max": 2,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_specular=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "vertexnormalsepsilon": {
+            "description": "Epsilon for vertex normals calculation avoids math issues arising from degenerate geometry.",
+            "dflt": 1e-12,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lighting_vertexnormalsepsilon=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "magic_underscores": "fig.update_traces(lighting=dict(...), selector=dict(type='isosurface'))"
+        },
+        "lightposition": {
+          "editType": "calc",
+          "role": "object",
+          "x": {
+            "description": "Numeric vector, representing the X coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_x=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "y": {
+            "description": "Numeric vector, representing the Y coordinate for each vertex.",
+            "dflt": 100000,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_y=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "z": {
+            "description": "Numeric vector, representing the Z coordinate for each vertex.",
+            "dflt": 0,
+            "editType": "calc",
+            "max": 100000,
+            "min": -100000,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(lightposition_z=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "magic_underscores": "fig.update_traces(lightposition=dict(...), selector=dict(type='isosurface'))"
+        },
+        "slices": {
+          "editType": "calc",
+          "role": "object",
+          "x": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(slices_x_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "locations": {
+              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis x except start and end.",
+              "dflt": [],
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(slices_x_locations=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "role": "object",
+            "show": {
+              "description": "Determines whether or not slice planes about the x dimension are drawn.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(slices_x_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "magic_underscores": "fig.update_traces(slices_x=dict(...), selector=dict(type='isosurface'))"
+          },
+          "y": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(slices_y_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "locations": {
+              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis y except start and end.",
+              "dflt": [],
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(slices_y_locations=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "role": "object",
+            "show": {
+              "description": "Determines whether or not slice planes about the y dimension are drawn.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(slices_y_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "magic_underscores": "fig.update_traces(slices_y=dict(...), selector=dict(type='isosurface'))"
+          },
+          "z": {
+            "editType": "calc",
+            "fill": {
+              "description": "Sets the fill ratio of the `slices`. The default fill value of the `slices` is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+              "dflt": 1,
+              "editType": "calc",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(slices_z_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+            },
+            "locations": {
+              "description": "Specifies the location(s) of slices on the axis. When not specified slices would be created for all points of the axis z except start and end.",
+              "dflt": [],
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(slices_z_locations=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+            "role": "object",
+            "show": {
+              "description": "Determines whether or not slice planes about the z dimension are drawn.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(slices_z_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattermap'))"
-          },
-          "namelength": {
-            "arrayOk": true,
-            "description": "Sets the default length (in number of characters) of the trace name in the hover labels for all traces. -1 shows the whole name regardless of length. 0-3 shows the first 0-3 characters, and an integer >3 will show the whole name if it is less than that many characters, but if it is longer, will truncate to `namelength - 3` characters and add an ellipsis.",
-            "dflt": 15,
-            "editType": "none",
-            "min": -1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(slices_z=dict(...), selector=dict(type='isosurface'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+          "magic_underscores": "fig.update_traces(slices=dict(...), selector=dict(type='isosurface'))"
+        },
+        "spaceframe": {
+          "editType": "calc",
+          "fill": {
+            "description": "Sets the fill ratio of the `spaceframe` elements. The default fill value is 0.15 meaning that only 15% of the area of every faces of tetras would be shaded. Applying a greater `fill` ratio would allow the creation of stronger elements or could be sued to have entirely closed areas (in case of using 1).",
+            "dflt": 0.15,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(spaceframe_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
           "role": "object",
-          "showarrow": {
-            "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
-            "dflt": true,
-            "editType": "none",
+          "show": {
+            "description": "Displays/hides tetrahedron shapes between minimum and maximum iso-values. Often useful when either caps or surfaces are disabled or filled with values less than 1.",
+            "dflt": false,
+            "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(spaceframe_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='scattermap'))"
-        },
-        "uirevision": {
-          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
-          "editType": "none",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(spaceframe=dict(...), selector=dict(type='isosurface'))"
         },
-        "stream": {
+        "surface": {
+          "count": {
+            "description": "Sets the number of iso-surfaces between minimum and maximum iso-values. By default this value is 2 meaning that only minimum and maximum surfaces would be drawn.",
+            "dflt": 2,
+            "editType": "calc",
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(surface_count=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
           "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
+          "fill": {
+            "description": "Sets the fill ratio of the iso-surface. The default fill value of the surface is 1 meaning that they are entirely shaded. On the other hand Applying a `fill` ratio less than one would allow the creation of openings parallel to the edges.",
+            "dflt": 1,
             "editType": "calc",
-            "max": 10000,
+            "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "magic_underscores": "fig.update_traces(surface_fill=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+          },
+          "pattern": {
+            "description": "Sets the surface pattern of the iso-surface 3-D sections. The default pattern of the surface is `all` meaning that the rest of surface elements would be shaded. The check options (either 1 or 2) could be used to draw half of the squares on the surface. Using various combinations of capital `A`, `B`, `C`, `D` and `E` may also be used to reduce the number of triangles on the iso-surfaces and creating other patterns of interest.",
+            "dflt": "all",
+            "editType": "calc",
+            "extras": [
+              "all",
+              "odd",
+              "even"
+            ],
+            "flags": [
+              "A",
+              "B",
+              "C",
+              "D",
+              "E"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(surface_pattern=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
           "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
+          "show": {
+            "description": "Hides/displays surfaces between minimum and maximum iso-values.",
+            "dflt": true,
             "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(surface_show=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
           },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scattermap'))"
+          "magic_underscores": "fig.update_traces(surface=dict(...), selector=dict(type='isosurface'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='scattermap'))"
+        "uirevision": {
+          "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
+          "editType": "none",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='isosurface'))"
+        },
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='isosurface'))"
       },
       "categories": [
-        "map",
-        "gl",
-        "symbols",
-        "showLegend",
-        "scatter-like"
+        "gl3d",
+        "showLegend"
       ],
       "meta": {
-        "description": "The data visualized as scatter point, lines or marker symbols on a MapLibre GL geographic map is provided by longitude/latitude pairs in `lon` and `lat`.",
-        "hrName": "scatter_map"
+        "description": "Draws isosurfaces between iso-min and iso-max values with coordinates given by four 1-dimensional arrays containing the `value`, `x`, `y` and `z` of every vertex of a uniform or non-uniform 3-D grid. Horizontal or vertical slices, caps as well as spaceframe between iso-min and iso-max values could also be drawn using this trace."
       },
-      "type": "scattermap"
+      "type": "isosurface"
     },
-    "scattermapbox": {
+    "scattergeo": {
       "animatable": false,
       "attributes": {
-        "type": "scattermapbox",
+        "type": "scattergeo",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -70500,35 +60361,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": true,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -70536,7 +60397,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -70546,7 +60407,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -70561,7 +60422,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "role": "object",
             "shadow": {
@@ -70569,13 +60430,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -70586,7 +60447,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -70599,7 +60460,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -70614,7 +60475,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -70627,9 +60488,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='scattergeo'))"
           },
           "role": "object",
           "text": {
@@ -70637,16 +60498,16 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='scattergeo'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "opacity": {
           "description": "Sets the opacity of the trace.",
@@ -70655,10 +60516,10 @@
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "mode": {
-          "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover.",
+          "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover. If there are less than 20 points and the trace is not stacked then the default is *lines+markers*. Otherwise, *lines*.",
           "dflt": "markers",
           "editType": "calc",
           "extras": [
@@ -70670,131 +60531,55 @@
             "text"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "lat": {
           "description": "Sets the latitude coordinates (in degrees North).",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
-        "latsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lat`.",
-          "editType": "none",
-          "valType": "string"
+        "geojson": {
+          "description": "Sets optional GeoJSON data associated with this trace. If not given, the features on the base map are used when `locations` is set. It can be set as a valid GeoJSON object or as a URL string. Note that we only accept GeoJSONs of type *FeatureCollection* or *Feature* with geometries of type *Polygon* or *MultiPolygon*.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(geojson=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
-        "lon": {
-          "description": "Sets the longitude coordinates (in degrees East).",
+        "featureidkey": {
+          "description": "Sets the key in GeoJSON features which is used as id to match the items included in the `locations` array. Only has an effect when `geojson` is set. Support nested property, for example *properties.name*.",
+          "dflt": "id",
           "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(featureidkey=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
-        "lonsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lon`.",
-          "editType": "none",
-          "valType": "string"
+        "locations": {
+          "description": "Sets the coordinates via location IDs or names. Coordinates correspond to the centroid of each location given. See `locationmode` for more info.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(locations=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
-        "cluster": {
-          "color": {
-            "arrayOk": true,
-            "description": "Sets the color for each cluster step.",
-            "editType": "calc",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(cluster_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
+        "lon": {
+          "description": "Sets the longitude coordinates (in degrees East).",
           "editType": "calc",
-          "enabled": {
-            "description": "Determines whether clustering is enabled or disabled.",
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(cluster_enabled=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "maxzoom": {
-            "description": "Sets the maximum zoom level. At zoom levels equal to or greater than this, points will never be clustered.",
-            "dflt": 24,
-            "editType": "calc",
-            "max": 24,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_maxzoom=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the marker opacity.",
-            "dflt": 1,
-            "editType": "calc",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_opacity=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "size": {
-            "arrayOk": true,
-            "description": "Sets the size for each cluster step.",
-            "dflt": 20,
-            "editType": "calc",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "step": {
-            "arrayOk": true,
-            "description": "Sets how many points it takes to create a cluster or advance to the next cluster step. Use this in conjunction with arrays for `size` and / or `color`. If an integer, steps start at multiples of this number. If an array, each step extends from the given value until one less than the next value.",
-            "dflt": -1,
-            "editType": "calc",
-            "min": -1,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(cluster_step=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "stepsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `step`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "magic_underscores": "fig.update_traces(cluster=dict(...), selector=dict(type='scattermapbox'))"
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "description": "Sets text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "textposition": {
-          "arrayOk": false,
+          "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
           "dflt": "middle center",
           "editType": "calc",
@@ -70810,44 +60595,34 @@
             "bottom center",
             "bottom right"
           ],
-          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "texttemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `lat`, `lon` and `text`.",
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `lat`, `lon`, `location` and `text`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "texttemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "hovertext": {
           "arrayOk": true,
-          "description": "Sets hover text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "description": "Sets hover text elements associated with each (lon,lat) pair or item in `locations`. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) or `locations` coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -70858,16 +60633,12 @@
           "flags": [
             "lon",
             "lat",
+            "location",
             "text",
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "hovertemplate": {
           "arrayOk": true,
@@ -70875,90 +60646,75 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
-        "subplot": {
-          "description": "mapbox subplots and traces are deprecated! Please consider switching to `map` subplots and traces. Learn more at: https://plotly.com/python/maplibre-migration/ as well as https://plotly.com/javascript/maplibre-migration/ Sets a reference between this trace's data coordinates and a mapbox subplot. If *mapbox* (the default value), the data refer to `layout.mapbox`. If *mapbox2*, the data refer to `layout.mapbox2`, and so on.",
-          "dflt": "mapbox",
+        "geo": {
+          "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on.",
+          "dflt": "geo",
           "editType": "calc",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(geo=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "marker": {
-          "allowoverlap": {
-            "description": "Flag to draw all symbols, even if they overlap.",
-            "dflt": false,
-            "editType": "calc",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_allowoverlap=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
           "angle": {
             "arrayOk": true,
-            "description": "Sets the marker orientation from true North, in degrees clockwise. When using the *auto* default, no rotation would be applied in perspective views which is different from using a zero angle.",
-            "dflt": "auto",
+            "description": "Sets the marker angle in respect to `angleref`.",
+            "dflt": 0,
             "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "valType": "angle",
+            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
+          "angleref": {
+            "description": "Sets the reference for marker angle. With *previous*, angle 0 points along the line from the previous point to this one. With *up*, angle 0 points toward the top of the screen. With *north*, angle 0 points north based on the current map projection.",
+            "dflt": "up",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "previous",
+              "up",
+              "north"
+            ],
+            "magic_underscores": "fig.update_traces(marker_angleref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
             "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "cauto": {
             "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
             "dflt": true,
             "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "cmax": {
             "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
@@ -70966,20 +60722,20 @@
             "editType": "calc",
             "impliedEdits": {
               "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "cmid": {
             "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "cmin": {
             "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
@@ -70987,17 +60743,17 @@
             "editType": "calc",
             "impliedEdits": {
               "cauto": false,
-              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "color": {
             "arrayOk": true,
             "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "coloraxis": {
             "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -71005,7 +60761,7 @@
             "editType": "calc",
             "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
             "valType": "subplotid",
-            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "colorbar": {
             "bgcolor": {
@@ -71013,14 +60769,14 @@
               "dflt": "rgba(0,0,0,0)",
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "bordercolor": {
               "description": "Sets the axis line color.",
               "dflt": "#444",
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "borderwidth": {
               "description": "Sets the width (in px) or the border enclosing this color bar.",
@@ -71028,17 +60784,17 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "dtick": {
               "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
               "editType": "calc",
               "impliedEdits": {
                 "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "editType": "calc",
             "exponentformat": {
@@ -71055,14 +60811,14 @@
                 "B",
                 "SI extended"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "labelalias": {
               "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
               "dflt": false,
               "editType": "calc",
               "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "len": {
               "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
@@ -71070,7 +60826,7 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "lenmode": {
               "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
@@ -71081,7 +60837,7 @@
                 "fraction",
                 "pixels"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "minexponent": {
               "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
@@ -71089,7 +60845,7 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "nticks": {
               "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
@@ -71097,7 +60853,7 @@
               "editType": "calc",
               "min": 0,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "orientation": {
               "description": "Sets the orientation of the colorbar.",
@@ -71108,14 +60864,14 @@
                 "h",
                 "v"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "outlinecolor": {
               "description": "Sets the axis line color.",
               "dflt": "#444",
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "outlinewidth": {
               "description": "Sets the width (in px) of the axis line.",
@@ -71123,7 +60879,7 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "role": "object",
             "separatethousands": {
@@ -71131,7 +60887,7 @@
               "dflt": false,
               "editType": "calc",
               "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "showexponent": {
               "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
@@ -71144,14 +60900,14 @@
                 "last",
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "showticklabels": {
               "description": "Determines whether or not the tick labels are drawn.",
               "dflt": true,
               "editType": "calc",
               "valType": "boolean",
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "showtickprefix": {
               "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
@@ -71164,7 +60920,7 @@
                 "last",
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "showticksuffix": {
               "description": "Same as `showtickprefix` but for tick suffixes.",
@@ -71177,7 +60933,7 @@
                 "last",
                 "none"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "thickness": {
               "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
@@ -71185,7 +60941,7 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "thicknessmode": {
               "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
@@ -71196,37 +60952,37 @@
                 "fraction",
                 "pixels"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tick0": {
               "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
               "editType": "calc",
               "impliedEdits": {
                 "tickmode": "linear",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "valType": "any",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickangle": {
               "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
               "dflt": "auto",
               "editType": "calc",
               "valType": "angle",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickcolor": {
               "description": "Sets the tick color.",
               "dflt": "#444",
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickfont": {
               "color": {
                 "editType": "calc",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "description": "Sets the color bar's tick label font",
               "editType": "calc",
@@ -71236,7 +60992,7 @@
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -71251,7 +61007,7 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "role": "object",
               "shadow": {
@@ -71259,13 +61015,13 @@
                 "dflt": "none",
                 "editType": "calc",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "size": {
                 "editType": "calc",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -71276,7 +61032,7 @@
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -71289,7 +61045,7 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
@@ -71304,7 +61060,7 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
@@ -71317,16 +61073,16 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='scattergeo'))"
             },
             "tickformat": {
               "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
               "dflt": "",
               "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickformatstops": {
               "items": {
@@ -71373,7 +61129,7 @@
                 }
               },
               "role": "object",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='scattergeo'))"
             },
             "ticklabeloverflow": {
               "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
@@ -71384,7 +61140,7 @@
                 "hide past div",
                 "hide past domain"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "ticklabelposition": {
               "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
@@ -71403,7 +61159,7 @@
                 "outside bottom",
                 "inside bottom"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "ticklabelstep": {
               "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
@@ -71411,7 +61167,7 @@
               "editType": "calc",
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "ticklen": {
               "description": "Sets the tick length (in px).",
@@ -71419,13 +61175,13 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickmode": {
               "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
               "editType": "calc",
               "impliedEdits": {
-                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "valType": "enumerated",
               "values": [
@@ -71433,14 +61189,14 @@
                 "linear",
                 "array"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickprefix": {
               "description": "Sets a tick label prefix.",
               "dflt": "",
               "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "ticks": {
               "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
@@ -71452,36 +61208,26 @@
                 "inside",
                 ""
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "ticksuffix": {
               "description": "Sets a tick label suffix.",
               "dflt": "",
               "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "ticktext": {
               "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
               "editType": "calc",
               "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "calc",
               "valType": "data_array",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
@@ -71489,7 +61235,7 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "title": {
               "editType": "calc",
@@ -71497,7 +61243,7 @@
                 "color": {
                   "editType": "calc",
                   "valType": "color",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "description": "Sets this color bar's title font.",
                 "editType": "calc",
@@ -71507,7 +61253,7 @@
                   "noBlank": true,
                   "strict": true,
                   "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "lineposition": {
                   "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -71522,7 +61268,7 @@
                     "through"
                   ],
                   "valType": "flaglist",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "role": "object",
                 "shadow": {
@@ -71530,13 +61276,13 @@
                   "dflt": "none",
                   "editType": "calc",
                   "valType": "string",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "size": {
                   "editType": "calc",
                   "min": 1,
                   "valType": "number",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "style": {
                   "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -71547,7 +61293,7 @@
                     "normal",
                     "italic"
                   ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "textcase": {
                   "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -71560,7 +61306,7 @@
                     "upper",
                     "lower"
                   ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "variant": {
                   "description": "Sets the variant of the font.",
@@ -71575,7 +61321,7 @@
                     "petite-caps",
                     "unicase"
                   ],
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
                 "weight": {
                   "description": "Sets the weight (or boldness) of the font.",
@@ -71588,13 +61334,13 @@
                   "max": 1000,
                   "min": 1,
                   "valType": "integer",
-                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
                 },
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='scattergeo'))"
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "calc",
                 "valType": "enumerated",
                 "values": [
@@ -71602,21 +61348,21 @@
                   "top",
                   "bottom"
                 ],
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
               "text": {
                 "description": "Sets the title of the color bar.",
                 "editType": "calc",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
               },
-              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='scattergeo'))"
             },
             "x": {
               "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
               "editType": "calc",
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "xanchor": {
               "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
@@ -71627,7 +61373,7 @@
                 "center",
                 "right"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "xpad": {
               "description": "Sets the amount of padding (in px) along the x direction.",
@@ -71635,7 +61381,7 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "xref": {
               "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
@@ -71646,63 +61392,198 @@
                 "container",
                 "paper"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "y": {
               "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
               "editType": "calc",
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "yanchor": {
+              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "top",
+                "middle",
+                "bottom"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "ypad": {
+              "description": "Sets the amount of padding (in px) along the y direction.",
+              "dflt": 10,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "yref": {
+              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+              "dflt": "paper",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "container",
+                "paper"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattergeo'))"
+          },
+          "colorscale": {
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "autocolorscale": false,
+              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "valType": "colorscale",
+            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "editType": "calc",
+          "gradient": {
+            "color": {
+              "arrayOk": true,
+              "description": "Sets the final color of the gradient fill: the center color for radial, the right for horizontal, or the bottom for vertical.",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_gradient_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "editType": "calc",
+            "role": "object",
+            "type": {
+              "arrayOk": true,
+              "description": "Sets the type of gradient used to fill the markers",
+              "dflt": "none",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "radial",
+                "horizontal",
+                "vertical",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_gradient_type=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_gradient=dict(...), selector=dict(type='scattergeo'))"
+          },
+          "line": {
+            "autocolorscale": {
+              "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.line.colorscale`. Has an effect only if in `marker.line.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "cauto": {
+              "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.line.color`) or the bounds set in `marker.line.cmin` and `marker.line.cmax` Has an effect only if in `marker.line.color` is set to a numerical array. Defaults to `false` when `marker.line.cmin` and `marker.line.cmax` are set by the user.",
+              "dflt": true,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              },
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_cauto=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "cmax": {
+              "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmin` must be set as well.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmax=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "cmid": {
+              "description": "Sets the mid-point of the color domain by scaling `marker.line.cmin` and/or `marker.line.cmax` to be equidistant to this point. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color`. Has no effect when `marker.line.cauto` is `false`.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_line_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmid=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "cmin": {
+              "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.line.color` is set to a numerical array. Value should have the same units as in `marker.line.color` and if set, `marker.line.cmax` must be set as well.",
+              "dflt": null,
+              "editType": "calc",
+              "impliedEdits": {
+                "cauto": false,
+                "magic_underscores": "fig.update_traces(marker_line_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              },
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_cmin=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "color": {
+              "arrayOk": true,
+              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "yanchor": {
-              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+            "coloraxis": {
+              "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+              "dflt": null,
               "editType": "calc",
-              "valType": "enumerated",
-              "values": [
-                "top",
-                "middle",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+              "valType": "subplotid",
+              "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "ypad": {
-              "description": "Sets the amount of padding (in px) along the y direction.",
-              "dflt": 10,
+            "colorscale": {
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "dflt": null,
               "editType": "calc",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "impliedEdits": {
+                "autocolorscale": false,
+                "magic_underscores": "fig.update_traces(marker_line_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+              },
+              "valType": "colorscale",
+              "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "yref": {
-              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-              "dflt": "paper",
+            "dash": {
+              "arrayOk": true,
+              "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+              "dflt": "solid",
               "editType": "calc",
-              "valType": "enumerated",
+              "valType": "string",
               "values": [
-                "container",
-                "paper"
+                "solid",
+                "dot",
+                "dash",
+                "longdash",
+                "dashdot",
+                "longdashdot"
               ],
-              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattermapbox'))"
-          },
-          "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-            "dflt": null,
             "editType": "calc",
-            "impliedEdits": {
-              "autocolorscale": false,
-              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "reversescale": {
+              "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_line_reversescale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "valType": "colorscale",
-            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
+            "role": "object",
+            "width": {
+              "arrayOk": true,
+              "description": "Sets the width (in px) of the lines bounding the marker points.",
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scattergeo'))"
           },
-          "editType": "calc",
           "opacity": {
             "arrayOk": true,
             "description": "Sets the marker opacity.",
@@ -71710,19 +61591,14 @@
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
             "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "role": "object",
           "showscale": {
@@ -71730,7 +61606,7 @@
             "dflt": false,
             "editType": "calc",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "size": {
             "arrayOk": true,
@@ -71739,7 +61615,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "sizemin": {
             "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.",
@@ -71747,7 +61623,7 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizemin=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(marker_sizemin=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "sizemode": {
             "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.",
@@ -71758,41 +61634,543 @@
               "diameter",
               "area"
             ],
-            "magic_underscores": "fig.update_traces(marker_sizemode=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "sizeref": {
-            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.",
-            "dflt": 1,
-            "editType": "calc",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "symbol": {
-            "arrayOk": true,
-            "description": "Sets the marker symbol. Full list: https://www.mapbox.com/maki-icons/ Note that the array `marker.color` and `marker.size` are only available for *circle* symbols.",
-            "dflt": "circle",
-            "editType": "calc",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(marker_sizemode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "sizeref": {
+            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.",
+            "dflt": 1,
+            "editType": "calc",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "standoff": {
+            "arrayOk": true,
+            "description": "Moves the marker away from the data point in the direction of `angle` (in px). This can be useful for example if you have another marker at this location and you want to point an arrowhead marker at it.",
+            "dflt": 0,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_standoff=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "symbol": {
+            "arrayOk": true,
+            "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
+            "dflt": "circle",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              0,
+              "0",
+              "circle",
+              100,
+              "100",
+              "circle-open",
+              200,
+              "200",
+              "circle-dot",
+              300,
+              "300",
+              "circle-open-dot",
+              1,
+              "1",
+              "square",
+              101,
+              "101",
+              "square-open",
+              201,
+              "201",
+              "square-dot",
+              301,
+              "301",
+              "square-open-dot",
+              2,
+              "2",
+              "diamond",
+              102,
+              "102",
+              "diamond-open",
+              202,
+              "202",
+              "diamond-dot",
+              302,
+              "302",
+              "diamond-open-dot",
+              3,
+              "3",
+              "cross",
+              103,
+              "103",
+              "cross-open",
+              203,
+              "203",
+              "cross-dot",
+              303,
+              "303",
+              "cross-open-dot",
+              4,
+              "4",
+              "x",
+              104,
+              "104",
+              "x-open",
+              204,
+              "204",
+              "x-dot",
+              304,
+              "304",
+              "x-open-dot",
+              5,
+              "5",
+              "triangle-up",
+              105,
+              "105",
+              "triangle-up-open",
+              205,
+              "205",
+              "triangle-up-dot",
+              305,
+              "305",
+              "triangle-up-open-dot",
+              6,
+              "6",
+              "triangle-down",
+              106,
+              "106",
+              "triangle-down-open",
+              206,
+              "206",
+              "triangle-down-dot",
+              306,
+              "306",
+              "triangle-down-open-dot",
+              7,
+              "7",
+              "triangle-left",
+              107,
+              "107",
+              "triangle-left-open",
+              207,
+              "207",
+              "triangle-left-dot",
+              307,
+              "307",
+              "triangle-left-open-dot",
+              8,
+              "8",
+              "triangle-right",
+              108,
+              "108",
+              "triangle-right-open",
+              208,
+              "208",
+              "triangle-right-dot",
+              308,
+              "308",
+              "triangle-right-open-dot",
+              9,
+              "9",
+              "triangle-ne",
+              109,
+              "109",
+              "triangle-ne-open",
+              209,
+              "209",
+              "triangle-ne-dot",
+              309,
+              "309",
+              "triangle-ne-open-dot",
+              10,
+              "10",
+              "triangle-se",
+              110,
+              "110",
+              "triangle-se-open",
+              210,
+              "210",
+              "triangle-se-dot",
+              310,
+              "310",
+              "triangle-se-open-dot",
+              11,
+              "11",
+              "triangle-sw",
+              111,
+              "111",
+              "triangle-sw-open",
+              211,
+              "211",
+              "triangle-sw-dot",
+              311,
+              "311",
+              "triangle-sw-open-dot",
+              12,
+              "12",
+              "triangle-nw",
+              112,
+              "112",
+              "triangle-nw-open",
+              212,
+              "212",
+              "triangle-nw-dot",
+              312,
+              "312",
+              "triangle-nw-open-dot",
+              13,
+              "13",
+              "pentagon",
+              113,
+              "113",
+              "pentagon-open",
+              213,
+              "213",
+              "pentagon-dot",
+              313,
+              "313",
+              "pentagon-open-dot",
+              14,
+              "14",
+              "hexagon",
+              114,
+              "114",
+              "hexagon-open",
+              214,
+              "214",
+              "hexagon-dot",
+              314,
+              "314",
+              "hexagon-open-dot",
+              15,
+              "15",
+              "hexagon2",
+              115,
+              "115",
+              "hexagon2-open",
+              215,
+              "215",
+              "hexagon2-dot",
+              315,
+              "315",
+              "hexagon2-open-dot",
+              16,
+              "16",
+              "octagon",
+              116,
+              "116",
+              "octagon-open",
+              216,
+              "216",
+              "octagon-dot",
+              316,
+              "316",
+              "octagon-open-dot",
+              17,
+              "17",
+              "star",
+              117,
+              "117",
+              "star-open",
+              217,
+              "217",
+              "star-dot",
+              317,
+              "317",
+              "star-open-dot",
+              18,
+              "18",
+              "hexagram",
+              118,
+              "118",
+              "hexagram-open",
+              218,
+              "218",
+              "hexagram-dot",
+              318,
+              "318",
+              "hexagram-open-dot",
+              19,
+              "19",
+              "star-triangle-up",
+              119,
+              "119",
+              "star-triangle-up-open",
+              219,
+              "219",
+              "star-triangle-up-dot",
+              319,
+              "319",
+              "star-triangle-up-open-dot",
+              20,
+              "20",
+              "star-triangle-down",
+              120,
+              "120",
+              "star-triangle-down-open",
+              220,
+              "220",
+              "star-triangle-down-dot",
+              320,
+              "320",
+              "star-triangle-down-open-dot",
+              21,
+              "21",
+              "star-square",
+              121,
+              "121",
+              "star-square-open",
+              221,
+              "221",
+              "star-square-dot",
+              321,
+              "321",
+              "star-square-open-dot",
+              22,
+              "22",
+              "star-diamond",
+              122,
+              "122",
+              "star-diamond-open",
+              222,
+              "222",
+              "star-diamond-dot",
+              322,
+              "322",
+              "star-diamond-open-dot",
+              23,
+              "23",
+              "diamond-tall",
+              123,
+              "123",
+              "diamond-tall-open",
+              223,
+              "223",
+              "diamond-tall-dot",
+              323,
+              "323",
+              "diamond-tall-open-dot",
+              24,
+              "24",
+              "diamond-wide",
+              124,
+              "124",
+              "diamond-wide-open",
+              224,
+              "224",
+              "diamond-wide-dot",
+              324,
+              "324",
+              "diamond-wide-open-dot",
+              25,
+              "25",
+              "hourglass",
+              125,
+              "125",
+              "hourglass-open",
+              26,
+              "26",
+              "bowtie",
+              126,
+              "126",
+              "bowtie-open",
+              27,
+              "27",
+              "circle-cross",
+              127,
+              "127",
+              "circle-cross-open",
+              28,
+              "28",
+              "circle-x",
+              128,
+              "128",
+              "circle-x-open",
+              29,
+              "29",
+              "square-cross",
+              129,
+              "129",
+              "square-cross-open",
+              30,
+              "30",
+              "square-x",
+              130,
+              "130",
+              "square-x-open",
+              31,
+              "31",
+              "diamond-cross",
+              131,
+              "131",
+              "diamond-cross-open",
+              32,
+              "32",
+              "diamond-x",
+              132,
+              "132",
+              "diamond-x-open",
+              33,
+              "33",
+              "cross-thin",
+              133,
+              "133",
+              "cross-thin-open",
+              34,
+              "34",
+              "x-thin",
+              134,
+              "134",
+              "x-thin-open",
+              35,
+              "35",
+              "asterisk",
+              135,
+              "135",
+              "asterisk-open",
+              36,
+              "36",
+              "hash",
+              136,
+              "136",
+              "hash-open",
+              236,
+              "236",
+              "hash-dot",
+              336,
+              "336",
+              "hash-open-dot",
+              37,
+              "37",
+              "y-up",
+              137,
+              "137",
+              "y-up-open",
+              38,
+              "38",
+              "y-down",
+              138,
+              "138",
+              "y-down-open",
+              39,
+              "39",
+              "y-left",
+              139,
+              "139",
+              "y-left-open",
+              40,
+              "40",
+              "y-right",
+              140,
+              "140",
+              "y-right-open",
+              41,
+              "41",
+              "line-ew",
+              141,
+              "141",
+              "line-ew-open",
+              42,
+              "42",
+              "line-ns",
+              142,
+              "142",
+              "line-ns-open",
+              43,
+              "43",
+              "line-ne",
+              143,
+              "143",
+              "line-ne-open",
+              44,
+              "44",
+              "line-nw",
+              144,
+              "144",
+              "line-nw-open",
+              45,
+              "45",
+              "arrow-up",
+              145,
+              "145",
+              "arrow-up-open",
+              46,
+              "46",
+              "arrow-down",
+              146,
+              "146",
+              "arrow-down-open",
+              47,
+              "47",
+              "arrow-left",
+              147,
+              "147",
+              "arrow-left-open",
+              48,
+              "48",
+              "arrow-right",
+              148,
+              "148",
+              "arrow-right-open",
+              49,
+              "49",
+              "arrow-bar-up",
+              149,
+              "149",
+              "arrow-bar-up-open",
+              50,
+              "50",
+              "arrow-bar-down",
+              150,
+              "150",
+              "arrow-bar-down-open",
+              51,
+              "51",
+              "arrow-bar-left",
+              151,
+              "151",
+              "arrow-bar-left-open",
+              52,
+              "52",
+              "arrow-bar-right",
+              152,
+              "152",
+              "arrow-bar-right-open",
+              53,
+              "53",
+              "arrow",
+              153,
+              "153",
+              "arrow-open",
+              54,
+              "54",
+              "arrow-wide",
+              154,
+              "154",
+              "arrow-wide-open"
+            ],
+            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattergeo'))"
         },
         "line": {
           "color": {
             "description": "Sets the line color.",
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "dash": {
+            "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
+            "dflt": "solid",
+            "editType": "calc",
+            "valType": "string",
+            "values": [
+              "solid",
+              "dot",
+              "dash",
+              "longdash",
+              "dashdot",
+              "longdashdot"
+            ],
+            "magic_underscores": "fig.update_traces(line_dash=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "editType": "calc",
           "role": "object",
@@ -71802,35 +62180,62 @@
             "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
-          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='scattergeo'))"
         },
         "textfont": {
           "color": {
+            "arrayOk": true,
             "editType": "calc",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
-          "description": "Sets the icon text font (color=mapbox.layer.paint.text-color, size=mapbox.layer.layout.text-size). Has an effect only when `type` is set to *symbol*.",
+          "description": "Sets the text font.",
           "editType": "calc",
           "family": {
+            "arrayOk": true,
             "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-            "dflt": "Open Sans Regular, Arial Unicode MS Regular",
             "editType": "calc",
             "noBlank": true,
             "strict": true,
             "valType": "string",
-            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "lineposition": {
+            "arrayOk": true,
+            "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+            "dflt": "none",
+            "editType": "calc",
+            "extras": [
+              "none"
+            ],
+            "flags": [
+              "under",
+              "over",
+              "through"
+            ],
+            "valType": "flaglist",
+            "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "role": "object",
+          "shadow": {
+            "arrayOk": true,
+            "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+            "dflt": "none",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
           "size": {
+            "arrayOk": true,
             "editType": "calc",
             "min": 1,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "style": {
+            "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
             "dflt": "normal",
             "editType": "calc",
@@ -71839,9 +62244,40 @@
               "normal",
               "italic"
             ],
-            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "textcase": {
+            "arrayOk": true,
+            "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "word caps",
+              "upper",
+              "lower"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+          },
+          "variant": {
+            "arrayOk": true,
+            "description": "Sets the variant of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "small-caps",
+              "all-small-caps",
+              "all-petite-caps",
+              "petite-caps",
+              "unicase"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "weight": {
+            "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
             "dflt": "normal",
             "editType": "calc",
@@ -71852,15 +62288,15 @@
             "max": 1000,
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
-          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattergeo'))"
         },
         "selectedpoints": {
           "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "selected": {
           "editType": "calc",
@@ -71869,7 +62305,7 @@
               "description": "Sets the marker color of selected points.",
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "editType": "calc",
             "opacity": {
@@ -71878,7 +62314,7 @@
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "role": "object",
             "size": {
@@ -71886,12 +62322,23 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='scattergeo'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='scattermapbox'))"
+          "textfont": {
+            "color": {
+              "description": "Sets the text font color of selected points.",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(selected_textfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "editType": "calc",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(selected_textfont=dict(...), selector=dict(type='scattergeo'))"
+          },
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='scattergeo'))"
         },
         "unselected": {
           "editType": "calc",
@@ -71900,7 +62347,7 @@
               "description": "Sets the marker color of unselected points, applied only when a selection exists.",
               "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "editType": "calc",
             "opacity": {
@@ -71909,7 +62356,7 @@
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "role": "object",
             "size": {
@@ -71917,25 +62364,30 @@
               "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='scattergeo'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='scattermapbox'))"
-        },
-        "below": {
-          "description": "Determines if this scattermapbox trace's layers are to be inserted before the layer with the specified ID. By default, scattermapbox layers are inserted above all the base layers. To place the scattermapbox layers above every other layer, set `below` to *''*.",
-          "editType": "calc",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "textfont": {
+            "color": {
+              "description": "Sets the text font color of unselected points, applied only when a selection exists.",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(unselected_textfont_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
+            },
+            "editType": "calc",
+            "role": "object",
+            "magic_underscores": "fig.update_traces(unselected_textfont=dict(...), selector=dict(type='scattergeo'))"
+          },
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='scattergeo'))"
         },
         "connectgaps": {
           "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.",
           "dflt": false,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "fill": {
           "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.",
@@ -71946,13 +62398,13 @@
             "none",
             "toself"
           ],
-          "magic_underscores": "fig.update_traces(fill=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(fill=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "fillcolor": {
           "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
           "editType": "calc",
           "valType": "color",
-          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "hoverlabel": {
           "align": {
@@ -71966,36 +62418,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "editType": "none",
           "font": {
@@ -72003,12 +62440,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -72019,12 +62451,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -72040,12 +62467,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "role": "object",
             "shadow": {
@@ -72054,24 +62476,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "style": {
               "arrayOk": true,
@@ -72083,12 +62495,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -72102,12 +62509,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "variant": {
               "arrayOk": true,
@@ -72123,12 +62525,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
             "weight": {
               "arrayOk": true,
@@ -72142,14 +62539,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattergeo'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -72158,12 +62550,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
           "role": "object",
           "showarrow": {
@@ -72171,68 +62558,58 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='scattergeo'))"
+        },
+        "locationmode": {
+          "description": "Determines the set of locations used to match entries in `locations` to regions on the map. Values *ISO-3*, *USA-states*, *country names* correspond to features on the base map and value *geojson-id* corresponds to features from a custom GeoJSON linked to the `geojson` attribute. *USA-states* accepts both two-letter abbreviations (e.g. *CA*) and full state names (e.g. *California*).",
+          "dflt": "ISO-3",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "ISO-3",
+            "USA-states",
+            "country names",
+            "geojson-id"
+          ],
+          "magic_underscores": "fig.update_traces(locationmode=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scattermapbox'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scattermapbox'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattergeo'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='scattermapbox'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='scattergeo'))"
       },
       "categories": [
-        "mapbox",
-        "gl",
+        "geo",
         "symbols",
         "showLegend",
         "scatter-like"
       ],
       "meta": {
-        "description": "*scattermapbox* trace is deprecated! Please consider switching to the *scattermap* trace type and `map` subplots. Learn more at: https://plotly.com/python/maplibre-migration/ as well as https://plotly.com/javascript/maplibre-migration/ The data visualized as scatter point, lines or marker symbols on a Mapbox GL geographic map is provided by longitude/latitude pairs in `lon` and `lat`.",
-        "hrName": "scatter_mapbox"
+        "description": "The data visualized as scatter point or lines on a geographic map is provided either by longitude/latitude pairs in `lon` and `lat` respectively or by geographic location IDs or names in `locations`.",
+        "hrName": "scatter_geo"
       },
-      "type": "scattermapbox"
+      "type": "scattergeo"
     },
-    "choroplethmap": {
+    "choropleth": {
       "animatable": false,
       "attributes": {
-        "type": "choroplethmap",
+        "type": "choropleth",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -72244,35 +62621,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": false,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -72280,7 +62657,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -72290,7 +62667,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -72305,7 +62682,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "role": "object",
             "shadow": {
@@ -72313,13 +62690,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -72330,7 +62707,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -72343,7 +62720,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -72358,7 +62735,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -72371,9 +62748,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='choropleth'))"
           },
           "role": "object",
           "text": {
@@ -72381,62 +62758,47 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='choropleth'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "z": {
           "description": "Sets the color values.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "geojson": {
-          "description": "Sets the GeoJSON data associated with this trace. It can be set as a valid GeoJSON object or as a URL string. Note that we only accept GeoJSONs of type *FeatureCollection* or *Feature* with geometries of type *Polygon* or *MultiPolygon*.",
+          "description": "Sets optional GeoJSON data associated with this trace. If not given, the features on the base map are used. It can be set as a valid GeoJSON object or as a URL string. Note that we only accept GeoJSONs of type *FeatureCollection* or *Feature* with geometries of type *Polygon* or *MultiPolygon*.",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(geojson=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(geojson=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "featureidkey": {
-          "description": "Sets the key in GeoJSON features which is used as id to match the items included in the `locations` array. Support nested property, for example *properties.name*.",
+          "description": "Sets the key in GeoJSON features which is used as id to match the items included in the `locations` array. Only has an effect when `geojson` is set. Support nested property, for example *properties.name*.",
           "dflt": "id",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(featureidkey=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(featureidkey=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "locations": {
-          "description": "Sets which features found in *geojson* to plot using their feature `id` field.",
+          "description": "Sets the coordinates via location IDs or names. See `locationmode` for more info.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(locations=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "locationssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(locations=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "text": {
           "arrayOk": true,
@@ -72444,12 +62806,7 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "hovertext": {
           "arrayOk": true,
@@ -72457,16 +62814,11 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -72481,62 +62833,42 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `properties` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
-        "subplot": {
-          "description": "Sets a reference between this trace's data coordinates and a map subplot. If *map* (the default value), the data refer to `layout.map`. If *map2*, the data refer to `layout.map2`, and so on.",
-          "dflt": "map",
+        "geo": {
+          "description": "Sets a reference between this trace's geospatial coordinates and a geographic map. If *geo* (the default value), the geospatial coordinates refer to `layout.geo`. If *geo2*, the geospatial coordinates refer to `layout.geo2`, and so on.",
+          "dflt": "geo",
           "editType": "calc",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(geo=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "coloraxis": {
           "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -72544,7 +62876,7 @@
           "editType": "calc",
           "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "marker": {
           "editType": "calc",
@@ -72553,14 +62885,9 @@
               "arrayOk": true,
               "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
               "dflt": "#444",
-              "editType": "plot",
+              "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "editType": "calc",
             "role": "object",
@@ -72568,35 +62895,25 @@
               "arrayOk": true,
               "description": "Sets the width (in px) of the lines bounding the marker points.",
               "dflt": 1,
-              "editType": "plot",
+              "editType": "calc",
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='choropleth'))"
           },
           "opacity": {
             "arrayOk": true,
             "description": "Sets the opacity of the locations.",
             "dflt": 1,
-            "editType": "plot",
+            "editType": "style",
             "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='choropleth'))"
         },
         "colorbar": {
           "bgcolor": {
@@ -72604,14 +62921,14 @@
             "dflt": "rgba(0,0,0,0)",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "bordercolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "borderwidth": {
             "description": "Sets the width (in px) or the border enclosing this color bar.",
@@ -72619,17 +62936,17 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "dtick": {
             "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
             "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "editType": "colorbars",
           "exponentformat": {
@@ -72646,14 +62963,14 @@
               "B",
               "SI extended"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "labelalias": {
             "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
             "dflt": false,
             "editType": "colorbars",
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "len": {
             "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
@@ -72661,7 +62978,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "lenmode": {
             "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
@@ -72672,7 +62989,7 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "minexponent": {
             "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
@@ -72680,7 +62997,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "nticks": {
             "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
@@ -72688,7 +63005,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "orientation": {
             "description": "Sets the orientation of the colorbar.",
@@ -72699,14 +63016,14 @@
               "h",
               "v"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "outlinecolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "outlinewidth": {
             "description": "Sets the width (in px) of the axis line.",
@@ -72714,7 +63031,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "role": "object",
           "separatethousands": {
@@ -72722,7 +63039,7 @@
             "dflt": false,
             "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "showexponent": {
             "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
@@ -72735,14 +63052,14 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "showticklabels": {
             "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
             "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "showtickprefix": {
             "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
@@ -72755,7 +63072,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "showticksuffix": {
             "description": "Same as `showtickprefix` but for tick suffixes.",
@@ -72768,7 +63085,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "thickness": {
             "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
@@ -72776,7 +63093,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "thicknessmode": {
             "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
@@ -72787,37 +63104,37 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tick0": {
             "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
             "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickangle": {
             "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
             "dflt": "auto",
             "editType": "colorbars",
             "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickcolor": {
             "description": "Sets the tick color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickfont": {
             "color": {
               "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "description": "Sets the color bar's tick label font",
             "editType": "colorbars",
@@ -72827,7 +63144,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -72842,7 +63159,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "role": "object",
             "shadow": {
@@ -72850,13 +63167,13 @@
               "dflt": "none",
               "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "size": {
               "editType": "colorbars",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -72867,7 +63184,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -72880,7 +63197,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -72895,7 +63212,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -72908,16 +63225,16 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='choropleth'))"
           },
           "tickformat": {
             "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickformatstops": {
             "items": {
@@ -72964,7 +63281,7 @@
               }
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='choropleth'))"
           },
           "ticklabeloverflow": {
             "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
@@ -72975,7 +63292,7 @@
               "hide past div",
               "hide past domain"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "ticklabelposition": {
             "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
@@ -72994,7 +63311,7 @@
               "outside bottom",
               "inside bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "ticklabelstep": {
             "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
@@ -73002,7 +63319,7 @@
             "editType": "colorbars",
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "ticklen": {
             "description": "Sets the tick length (in px).",
@@ -73010,13 +63327,13 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickmode": {
             "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
             "editType": "colorbars",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "valType": "enumerated",
             "values": [
@@ -73024,14 +63341,14 @@
               "linear",
               "array"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickprefix": {
             "description": "Sets a tick label prefix.",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "ticks": {
             "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
@@ -73043,36 +63360,26 @@
               "inside",
               ""
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "ticksuffix": {
             "description": "Sets a tick label suffix.",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "ticktext": {
             "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
             "editType": "colorbars",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "colorbars",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
@@ -73080,7 +63387,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "title": {
             "editType": "colorbars",
@@ -73088,7 +63395,7 @@
               "color": {
                 "editType": "colorbars",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "description": "Sets this color bar's title font.",
               "editType": "colorbars",
@@ -73098,7 +63405,7 @@
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -73113,7 +63420,7 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "role": "object",
               "shadow": {
@@ -73121,13 +63428,13 @@
                 "dflt": "none",
                 "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "size": {
                 "editType": "colorbars",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -73138,7 +63445,7 @@
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -73151,7 +63458,7 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
@@ -73166,7 +63473,7 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
@@ -73179,13 +63486,13 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
               },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='choropleth'))"
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
@@ -73193,21 +63500,21 @@
                 "top",
                 "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "text": {
               "description": "Sets the title of the color bar.",
               "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='choropleth'))"
           },
           "x": {
             "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
             "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "xanchor": {
             "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
@@ -73218,7 +63525,7 @@
               "center",
               "right"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "xpad": {
             "description": "Sets the amount of padding (in px) along the x direction.",
@@ -73226,7 +63533,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "xref": {
             "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
@@ -73237,13 +63544,13 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "y": {
             "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
             "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "yanchor": {
             "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
@@ -73254,7 +63561,7 @@
               "middle",
               "bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "ypad": {
             "description": "Sets the amount of padding (in px) along the y direction.",
@@ -73262,7 +63569,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "yref": {
             "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
@@ -73273,54 +63580,54 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='choropleth'))"
         },
         "autocolorscale": {
           "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "showscale": {
           "description": "Determines whether or not a colorbar is displayed for this trace.",
           "dflt": true,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "reversescale": {
           "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
           "dflt": false,
           "editType": "plot",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "zauto": {
           "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "zmax": {
           "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
@@ -73328,20 +63635,20 @@
           "editType": "calc",
           "impliedEdits": {
             "zauto": false,
-            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "zmid": {
           "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "zmin": {
           "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
@@ -73349,16 +63656,16 @@
           "editType": "calc",
           "impliedEdits": {
             "zauto": false,
-            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "selectedpoints": {
           "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "selected": {
           "editType": "plot",
@@ -73366,17 +63673,17 @@
             "editType": "plot",
             "opacity": {
               "description": "Sets the marker opacity of selected points.",
-              "editType": "plot",
+              "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='choropleth'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='choropleth'))"
         },
         "unselected": {
           "editType": "plot",
@@ -73384,23 +63691,17 @@
             "editType": "plot",
             "opacity": {
               "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
-              "editType": "plot",
+              "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='choropleth'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='choroplethmap'))"
-        },
-        "below": {
-          "description": "Determines if the choropleth polygons will be inserted before the layer with the specified ID. By default, choroplethmap traces are placed above the water layers. If set to '', the layer will be inserted above every existing layer.",
-          "editType": "plot",
-          "valType": "string",
-          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='choropleth'))"
         },
         "hoverlabel": {
           "align": {
@@ -73414,36 +63715,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "editType": "none",
           "font": {
@@ -73451,12 +63737,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -73467,12 +63748,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -73488,12 +63764,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "role": "object",
             "shadow": {
@@ -73502,24 +63773,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "style": {
               "arrayOk": true,
@@ -73531,12 +63792,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -73550,12 +63806,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "variant": {
               "arrayOk": true,
@@ -73571,12 +63822,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
             "weight": {
               "arrayOk": true,
@@ -73590,14 +63836,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='choropleth'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -73606,12 +63847,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
           "role": "object",
           "showarrow": {
@@ -73619,67 +63855,56 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='choropleth'))"
+        },
+        "locationmode": {
+          "description": "Determines the set of locations used to match entries in `locations` to regions on the map. Values *ISO-3*, *USA-states*, *country names* correspond to features on the base map and value *geojson-id* corresponds to features from a custom GeoJSON linked to the `geojson` attribute. *USA-states* accepts both two-letter abbreviations (e.g. *CA*) and full state names (e.g. *California*).",
+          "dflt": "ISO-3",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "ISO-3",
+            "USA-states",
+            "country names",
+            "geojson-id"
+          ],
+          "magic_underscores": "fig.update_traces(locationmode=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='choroplethmap'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='choropleth'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='choroplethmap'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='choropleth'))"
       },
       "categories": [
-        "map",
-        "gl",
+        "geo",
         "noOpacity",
         "showLegend"
       ],
       "meta": {
-        "description": "GeoJSON features to be filled are set in `geojson` The data that describes the choropleth value-to-color mapping is set in `locations` and `z`.",
-        "hr_name": "choropleth_map"
+        "description": "The data that describes the choropleth value-to-color mapping is set in `z`. The geographic locations corresponding to each value in `z` are set in `locations`."
       },
-      "type": "choroplethmap"
+      "type": "choropleth"
     },
-    "choroplethmapbox": {
+    "scattermap": {
       "animatable": false,
       "attributes": {
-        "type": "choroplethmapbox",
+        "type": "scattermap",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -73691,35 +63916,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
-          "dflt": false,
+          "dflt": true,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -73727,7 +63952,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -73737,7 +63962,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -73752,7 +63977,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "role": "object",
             "shadow": {
@@ -73760,13 +63985,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -73777,7 +64002,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -73790,7 +64015,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -73805,7 +64030,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -73818,9 +64043,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='scattermap'))"
           },
           "role": "object",
           "text": {
@@ -73828,92 +64053,167 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='scattermap'))"
+        },
+        "legendwidth": {
+          "description": "Sets the width (in px or fraction) of the legend for this trace.",
+          "editType": "style",
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "opacity": {
+          "description": "Sets the opacity of the trace.",
+          "dflt": 1,
+          "editType": "style",
+          "max": 1,
+          "min": 0,
+          "valType": "number",
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "mode": {
+          "description": "Determines the drawing mode for this scatter trace. If the provided `mode` includes *text* then the `text` elements appear at the coordinates. Otherwise, the `text` elements appear on hover.",
+          "dflt": "markers",
+          "editType": "calc",
+          "extras": [
+            "none"
+          ],
+          "flags": [
+            "lines",
+            "markers",
+            "text"
+          ],
+          "valType": "flaglist",
+          "magic_underscores": "fig.update_traces(mode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "ids": {
+          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "lat": {
+          "description": "Sets the latitude coordinates (in degrees North).",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "lon": {
+          "description": "Sets the longitude coordinates (in degrees East).",
+          "editType": "calc",
+          "valType": "data_array",
+          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "cluster": {
+          "color": {
+            "arrayOk": true,
+            "description": "Sets the color for each cluster step.",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(cluster_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "editType": "calc",
+          "enabled": {
+            "description": "Determines whether clustering is enabled or disabled.",
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(cluster_enabled=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "maxzoom": {
+            "description": "Sets the maximum zoom level. At zoom levels equal to or greater than this, points will never be clustered.",
+            "dflt": 24,
+            "editType": "calc",
+            "max": 24,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(cluster_maxzoom=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "opacity": {
+            "arrayOk": true,
+            "description": "Sets the marker opacity.",
+            "dflt": 1,
+            "editType": "calc",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(cluster_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "role": "object",
+          "size": {
+            "arrayOk": true,
+            "description": "Sets the size for each cluster step.",
+            "dflt": 20,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(cluster_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "step": {
+            "arrayOk": true,
+            "description": "Sets how many points it takes to create a cluster or advance to the next cluster step. Use this in conjunction with arrays for `size` and / or `color`. If an integer, steps start at multiples of this number. If an array, each step extends from the given value until one less than the next value.",
+            "dflt": -1,
+            "editType": "calc",
+            "min": -1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(cluster_step=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='choroplethmapbox'))"
-        },
-        "legendwidth": {
-          "description": "Sets the width (in px or fraction) of the legend for this trace.",
-          "editType": "style",
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "ids": {
-          "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "z": {
-          "description": "Sets the color values.",
-          "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "geojson": {
-          "description": "Sets the GeoJSON data associated with this trace. It can be set as a valid GeoJSON object or as a URL string. Note that we only accept GeoJSONs of type *FeatureCollection* or *Feature* with geometries of type *Polygon* or *MultiPolygon*.",
-          "editType": "calc",
-          "valType": "any",
-          "magic_underscores": "fig.update_traces(geojson=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(cluster=dict(...), selector=dict(type='scattermap'))"
         },
-        "featureidkey": {
-          "description": "Sets the key in GeoJSON features which is used as id to match the items included in the `locations` array. Support nested property, for example *properties.name*.",
-          "dflt": "id",
+        "text": {
+          "arrayOk": true,
+          "description": "Sets text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(featureidkey=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
-        "locations": {
-          "description": "Sets which features found in *geojson* to plot using their feature `id` field.",
+        "textposition": {
+          "arrayOk": false,
+          "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
+          "dflt": "middle center",
           "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(locations=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "locationssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `locations`.",
-          "editType": "none",
-          "valType": "string"
+          "valType": "enumerated",
+          "values": [
+            "top left",
+            "top center",
+            "top right",
+            "middle left",
+            "middle center",
+            "middle right",
+            "bottom left",
+            "bottom center",
+            "bottom right"
+          ],
+          "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
-        "text": {
+        "texttemplate": {
           "arrayOk": true,
-          "description": "Sets the text elements associated with each location.",
+          "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `lat`, `lon` and `text`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(texttemplate=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+        "texttemplatefallback": {
+          "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
+          "dflt": "-",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "hovertext": {
           "arrayOk": true,
-          "description": "Same as `text`.",
+          "description": "Sets hover text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -73922,932 +64222,1048 @@
             "skip"
           ],
           "flags": [
-            "location",
-            "z",
+            "lon",
+            "lat",
             "text",
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `properties` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
-          "editType": "none",
+          "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
-          "editType": "none",
+          "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "subplot": {
-          "description": "mapbox subplots and traces are deprecated! Please consider switching to `map` subplots and traces. Learn more at: https://plotly.com/python/maplibre-migration/ as well as https://plotly.com/javascript/maplibre-migration/ Sets a reference between this trace's data coordinates and a mapbox subplot. If *mapbox* (the default value), the data refer to `layout.mapbox`. If *mapbox2*, the data refer to `layout.mapbox2`, and so on.",
-          "dflt": "mapbox",
-          "editType": "calc",
-          "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "coloraxis": {
-          "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
-          "dflt": null,
+          "description": "Sets a reference between this trace's data coordinates and a map subplot. If *map* (the default value), the data refer to `layout.map`. If *map2*, the data refer to `layout.map2`, and so on.",
+          "dflt": "map",
           "editType": "calc",
-          "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "marker": {
-          "editType": "calc",
-          "line": {
-            "color": {
-              "arrayOk": true,
-              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
+          "allowoverlap": {
+            "description": "Flag to draw all symbols, even if they overlap.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_allowoverlap=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "angle": {
+            "arrayOk": true,
+            "description": "Sets the marker orientation from true North, in degrees clockwise. When using the *auto* default, no rotation would be applied in perspective views which is different from using a zero angle.",
+            "dflt": "auto",
+            "editType": "calc",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "autocolorscale": {
+            "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
+            "dflt": true,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_autocolorscale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "cauto": {
+            "description": "Determines whether or not the color domain is computed with respect to the input data (here in `marker.color`) or the bounds set in `marker.cmin` and `marker.cmax` Has an effect only if in `marker.color` is set to a numerical array. Defaults to `false` when `marker.cmin` and `marker.cmax` are set by the user.",
+            "dflt": true,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_cauto=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "cmax": {
+            "description": "Sets the upper bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmin` must be set as well.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmax=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "cmid": {
+            "description": "Sets the mid-point of the color domain by scaling `marker.cmin` and/or `marker.cmax` to be equidistant to this point. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color`. Has no effect when `marker.cauto` is `false`.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "magic_underscores": "fig.update_traces(marker_cmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmid=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "cmin": {
+            "description": "Sets the lower bound of the color domain. Has an effect only if in `marker.color` is set to a numerical array. Value should have the same units as in `marker.color` and if set, `marker.cmax` must be set as well.",
+            "dflt": null,
+            "editType": "calc",
+            "impliedEdits": {
+              "cauto": false,
+              "magic_underscores": "fig.update_traces(marker_cmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_cmin=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "color": {
+            "arrayOk": true,
+            "description": "Sets the marker color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.cmin` and `marker.cmax` if set.",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(marker_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "coloraxis": {
+            "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
+            "dflt": null,
+            "editType": "calc",
+            "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
+            "valType": "subplotid",
+            "magic_underscores": "fig.update_traces(marker_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "colorbar": {
+            "bgcolor": {
+              "description": "Sets the color of padded area.",
+              "dflt": "rgba(0,0,0,0)",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "bordercolor": {
+              "description": "Sets the axis line color.",
               "dflt": "#444",
-              "editType": "plot",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "borderwidth": {
+              "description": "Sets the width (in px) or the border enclosing this color bar.",
+              "dflt": 0,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "dtick": {
+              "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
+              "editType": "calc",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "editType": "calc",
+            "exponentformat": {
+              "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
+              "dflt": "B",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "none",
+                "e",
+                "E",
+                "power",
+                "SI",
+                "B",
+                "SI extended"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "labelalias": {
+              "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "len": {
+              "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_len=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "lenmode": {
+              "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
+              "dflt": "fraction",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "minexponent": {
+              "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
+              "dflt": 3,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "nticks": {
+              "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
+              "dflt": 0,
+              "editType": "calc",
+              "min": 0,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "orientation": {
+              "description": "Sets the orientation of the colorbar.",
+              "dflt": "v",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "h",
+                "v"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "outlinecolor": {
+              "description": "Sets the axis line color.",
+              "dflt": "#444",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "outlinewidth": {
+              "description": "Sets the width (in px) of the axis line.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "role": "object",
+            "separatethousands": {
+              "description": "If \"true\", even 4-digit integers are separated",
+              "dflt": false,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "showexponent": {
+              "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "showticklabels": {
+              "description": "Determines whether or not the tick labels are drawn.",
+              "dflt": true,
+              "editType": "calc",
+              "valType": "boolean",
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "showtickprefix": {
+              "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "showticksuffix": {
+              "description": "Same as `showtickprefix` but for tick suffixes.",
+              "dflt": "all",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "all",
+                "first",
+                "last",
+                "none"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "thickness": {
+              "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
+              "dflt": 30,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "thicknessmode": {
+              "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
+              "dflt": "pixels",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "fraction",
+                "pixels"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "tick0": {
+              "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
+              "editType": "calc",
+              "impliedEdits": {
+                "tickmode": "linear",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "valType": "any",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "tickangle": {
+              "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
+              "dflt": "auto",
+              "editType": "calc",
+              "valType": "angle",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "tickcolor": {
+              "description": "Sets the tick color.",
+              "dflt": "#444",
+              "editType": "calc",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "tickfont": {
+              "color": {
+                "editType": "calc",
+                "valType": "color",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "description": "Sets the color bar's tick label font",
+              "editType": "calc",
+              "family": {
+                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                "editType": "calc",
+                "noBlank": true,
+                "strict": true,
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "lineposition": {
+                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                "dflt": "none",
+                "editType": "calc",
+                "extras": [
+                  "none"
+                ],
+                "flags": [
+                  "under",
+                  "over",
+                  "through"
+                ],
+                "valType": "flaglist",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "role": "object",
+              "shadow": {
+                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                "dflt": "none",
+                "editType": "calc",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "size": {
+                "editType": "calc",
+                "min": 1,
+                "valType": "number",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "style": {
+                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                "dflt": "normal",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "italic"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "textcase": {
+                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                "dflt": "normal",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "word caps",
+                  "upper",
+                  "lower"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "variant": {
+                "description": "Sets the variant of the font.",
+                "dflt": "normal",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "normal",
+                  "small-caps",
+                  "all-small-caps",
+                  "all-petite-caps",
+                  "petite-caps",
+                  "unicase"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "weight": {
+                "description": "Sets the weight (or boldness) of the font.",
+                "dflt": "normal",
+                "editType": "calc",
+                "extras": [
+                  "normal",
+                  "bold"
+                ],
+                "max": 1000,
+                "min": 1,
+                "valType": "integer",
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickfont=dict(...), selector=dict(type='scattermap'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+            "tickformat": {
+              "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
+              "dflt": "",
+              "editType": "calc",
+              "valType": "string",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "editType": "calc",
-            "role": "object",
-            "width": {
-              "arrayOk": true,
-              "description": "Sets the width (in px) of the lines bounding the marker points.",
-              "dflt": 1,
-              "editType": "plot",
-              "min": 0,
-              "valType": "number",
-              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "tickformatstops": {
+              "items": {
+                "tickformatstop": {
+                  "dtickrange": {
+                    "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
+                    "editType": "calc",
+                    "items": [
+                      {
+                        "editType": "calc",
+                        "valType": "any"
+                      },
+                      {
+                        "editType": "calc",
+                        "valType": "any"
+                      }
+                    ],
+                    "valType": "info_array"
+                  },
+                  "editType": "calc",
+                  "enabled": {
+                    "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
+                    "dflt": true,
+                    "editType": "calc",
+                    "valType": "boolean"
+                  },
+                  "name": {
+                    "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
+                    "editType": "calc",
+                    "valType": "string"
+                  },
+                  "role": "object",
+                  "templateitemname": {
+                    "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
+                    "editType": "calc",
+                    "valType": "string"
+                  },
+                  "value": {
+                    "description": "string - dtickformat for described zoom level, the same as *tickformat*",
+                    "dflt": "",
+                    "editType": "calc",
+                    "valType": "string"
+                  }
+                }
+              },
+              "role": "object",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickformatstops=list(...), selector=dict(type='scattermap'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
+            "ticklabeloverflow": {
+              "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "allow",
+                "hide past div",
+                "hide past domain"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='choroplethmapbox'))"
-          },
-          "opacity": {
-            "arrayOk": true,
-            "description": "Sets the opacity of the locations.",
-            "dflt": 1,
-            "editType": "plot",
-            "max": 1,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "role": "object",
-          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='choroplethmapbox'))"
-        },
-        "colorbar": {
-          "bgcolor": {
-            "description": "Sets the color of padded area.",
-            "dflt": "rgba(0,0,0,0)",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "bordercolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "borderwidth": {
-            "description": "Sets the width (in px) or the border enclosing this color bar.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "dtick": {
-            "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "ticklabelposition": {
+              "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
+              "dflt": "outside",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "outside",
+                "inside",
+                "outside top",
+                "inside top",
+                "outside left",
+                "inside left",
+                "outside right",
+                "inside right",
+                "outside bottom",
+                "inside bottom"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "editType": "colorbars",
-          "exponentformat": {
-            "description": "Determines a formatting rule for the tick exponents. For example, consider the number 1,000,000,000. If *none*, it appears as 1,000,000,000. If *e*, 1e+9. If *E*, 1E+9. If *power*, 1x10^9 (with 9 in a super script). If *SI*, 1G. If *B*, 1B. *SI* uses prefixes from \"femto\" f (10^-15) to \"tera\" T (10^12). *SI extended* covers instead the full SI range from \"quecto\" q (10^-30) to \"quetta\" Q (10^30). If *SI* or *SI extended* is used and the exponent is beyond the above ranges, the formatting rule will automatically be switched to the power notation.",
-            "dflt": "B",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "none",
-              "e",
-              "E",
-              "power",
-              "SI",
-              "B",
-              "SI extended"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "labelalias": {
-            "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "len": {
-            "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "lenmode": {
-            "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
-            "dflt": "fraction",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "minexponent": {
-            "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
-            "dflt": 3,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "nticks": {
-            "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
-            "dflt": 0,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "orientation": {
-            "description": "Sets the orientation of the colorbar.",
-            "dflt": "v",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "h",
-              "v"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "outlinecolor": {
-            "description": "Sets the axis line color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "outlinewidth": {
-            "description": "Sets the width (in px) of the axis line.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "role": "object",
-          "separatethousands": {
-            "description": "If \"true\", even 4-digit integers are separated",
-            "dflt": false,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "showexponent": {
-            "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "showticklabels": {
-            "description": "Determines whether or not the tick labels are drawn.",
-            "dflt": true,
-            "editType": "colorbars",
-            "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "showtickprefix": {
-            "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "showticksuffix": {
-            "description": "Same as `showtickprefix` but for tick suffixes.",
-            "dflt": "all",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "all",
-              "first",
-              "last",
-              "none"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "thickness": {
-            "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
-            "dflt": 30,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "thicknessmode": {
-            "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
-            "dflt": "pixels",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "fraction",
-              "pixels"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "tick0": {
-            "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
-            "editType": "colorbars",
-            "impliedEdits": {
-              "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "ticklabelstep": {
+              "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 1,
+              "valType": "integer",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "tickangle": {
-            "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
-            "dflt": "auto",
-            "editType": "colorbars",
-            "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "tickcolor": {
-            "description": "Sets the tick color.",
-            "dflt": "#444",
-            "editType": "colorbars",
-            "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "tickfont": {
-            "color": {
-              "editType": "colorbars",
-              "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "ticklen": {
+              "description": "Sets the tick length (in px).",
+              "dflt": 5,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "description": "Sets the color bar's tick label font",
-            "editType": "colorbars",
-            "family": {
-              "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-              "editType": "colorbars",
-              "noBlank": true,
-              "strict": true,
+            "tickmode": {
+              "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
+              "editType": "calc",
+              "impliedEdits": {
+                "magic_underscores": "fig.update_traces(marker_colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "valType": "enumerated",
+              "values": [
+                "auto",
+                "linear",
+                "array"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "tickprefix": {
+              "description": "Sets a tick label prefix.",
+              "dflt": "",
+              "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "lineposition": {
-              "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-              "dflt": "none",
-              "editType": "colorbars",
-              "extras": [
-                "none"
-              ],
-              "flags": [
-                "under",
-                "over",
-                "through"
+            "ticks": {
+              "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
+              "dflt": "",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "outside",
+                "inside",
+                ""
               ],
-              "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "role": "object",
-            "shadow": {
-              "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-              "dflt": "none",
-              "editType": "colorbars",
+            "ticksuffix": {
+              "description": "Sets a tick label suffix.",
+              "dflt": "",
+              "editType": "calc",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "ticktext": {
+              "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "tickvals": {
+              "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
+              "editType": "calc",
+              "valType": "data_array",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "tickwidth": {
+              "description": "Sets the tick width (in px).",
+              "dflt": 1,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "title": {
+              "editType": "calc",
+              "font": {
+                "color": {
+                  "editType": "calc",
+                  "valType": "color",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "description": "Sets this color bar's title font.",
+                "editType": "calc",
+                "family": {
+                  "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+                  "editType": "calc",
+                  "noBlank": true,
+                  "strict": true,
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "lineposition": {
+                  "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
+                  "dflt": "none",
+                  "editType": "calc",
+                  "extras": [
+                    "none"
+                  ],
+                  "flags": [
+                    "under",
+                    "over",
+                    "through"
+                  ],
+                  "valType": "flaglist",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "role": "object",
+                "shadow": {
+                  "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
+                  "dflt": "none",
+                  "editType": "calc",
+                  "valType": "string",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "size": {
+                  "editType": "calc",
+                  "min": 1,
+                  "valType": "number",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "style": {
+                  "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "italic"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "textcase": {
+                  "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "word caps",
+                    "upper",
+                    "lower"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "variant": {
+                  "description": "Sets the variant of the font.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "valType": "enumerated",
+                  "values": [
+                    "normal",
+                    "small-caps",
+                    "all-small-caps",
+                    "all-petite-caps",
+                    "petite-caps",
+                    "unicase"
+                  ],
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "weight": {
+                  "description": "Sets the weight (or boldness) of the font.",
+                  "dflt": "normal",
+                  "editType": "calc",
+                  "extras": [
+                    "normal",
+                    "bold"
+                  ],
+                  "max": 1000,
+                  "min": 1,
+                  "valType": "integer",
+                  "magic_underscores": "fig.update_traces(marker_colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+                },
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_font=dict(...), selector=dict(type='scattermap'))"
+              },
+              "role": "object",
+              "side": {
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
+                "editType": "calc",
+                "valType": "enumerated",
+                "values": [
+                  "right",
+                  "top",
+                  "bottom"
+                ],
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "text": {
+                "description": "Sets the title of the color bar.",
+                "editType": "calc",
+                "valType": "string",
+                "magic_underscores": "fig.update_traces(marker_colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+              },
+              "magic_underscores": "fig.update_traces(marker_colorbar_title=dict(...), selector=dict(type='scattermap'))"
             },
-            "size": {
-              "editType": "colorbars",
-              "min": 1,
+            "x": {
+              "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
+              "editType": "calc",
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_x=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "style": {
-              "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-              "dflt": "normal",
-              "editType": "colorbars",
+            "xanchor": {
+              "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "italic"
+                "left",
+                "center",
+                "right"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "textcase": {
-              "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-              "dflt": "normal",
-              "editType": "colorbars",
+            "xpad": {
+              "description": "Sets the amount of padding (in px) along the x direction.",
+              "dflt": 10,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "xref": {
+              "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
+              "dflt": "paper",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "word caps",
-                "upper",
-                "lower"
+                "container",
+                "paper"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_xref=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "variant": {
-              "description": "Sets the variant of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
+            "y": {
+              "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
+              "editType": "calc",
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_y=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "yanchor": {
+              "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
+              "editType": "calc",
               "valType": "enumerated",
               "values": [
-                "normal",
-                "small-caps",
-                "all-small-caps",
-                "all-petite-caps",
-                "petite-caps",
-                "unicase"
+                "top",
+                "middle",
+                "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(marker_colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "weight": {
-              "description": "Sets the weight (or boldness) of the font.",
-              "dflt": "normal",
-              "editType": "colorbars",
-              "extras": [
-                "normal",
-                "bold"
-              ],
-              "max": 1000,
-              "min": 1,
-              "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "ypad": {
+              "description": "Sets the amount of padding (in px) along the y direction.",
+              "dflt": 10,
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='choroplethmapbox'))"
-          },
-          "tickformat": {
-            "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "tickformatstops": {
-            "items": {
-              "tickformatstop": {
-                "dtickrange": {
-                  "description": "range [*min*, *max*], where *min*, *max* - dtick values which describe some zoom level, it is possible to omit *min* or *max* value by passing *null*",
-                  "editType": "colorbars",
-                  "items": [
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    },
-                    {
-                      "editType": "colorbars",
-                      "valType": "any"
-                    }
-                  ],
-                  "valType": "info_array"
-                },
-                "editType": "colorbars",
-                "enabled": {
-                  "description": "Determines whether or not this stop is used. If `false`, this stop is ignored even within its `dtickrange`.",
-                  "dflt": true,
-                  "editType": "colorbars",
-                  "valType": "boolean"
-                },
-                "name": {
-                  "description": "When used in a template, named items are created in the output figure in addition to any items the figure already has in this array. You can modify these items in the output figure by making your own item with `templateitemname` matching this `name` alongside your modifications (including `visible: false` or `enabled: false` to hide it). Has no effect outside of a template.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "role": "object",
-                "templateitemname": {
-                  "description": "Used to refer to a named item in this array in the template. Named items from the template will be created even without a matching item in the input figure, but you can modify one by making an item with `templateitemname` matching its `name`, alongside your modifications (including `visible: false` or `enabled: false` to hide it). If there is no template or no matching item, this item will be hidden unless you explicitly show it with `visible: true`.",
-                  "editType": "colorbars",
-                  "valType": "string"
-                },
-                "value": {
-                  "description": "string - dtickformat for described zoom level, the same as *tickformat*",
-                  "dflt": "",
-                  "editType": "colorbars",
-                  "valType": "string"
-                }
-              }
+            "yref": {
+              "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
+              "dflt": "paper",
+              "editType": "calc",
+              "valType": "enumerated",
+              "values": [
+                "container",
+                "paper"
+              ],
+              "magic_underscores": "fig.update_traces(marker_colorbar_yref=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='choroplethmapbox'))"
-          },
-          "ticklabeloverflow": {
-            "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "allow",
-              "hide past div",
-              "hide past domain"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "ticklabelposition": {
-            "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
-            "dflt": "outside",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              "outside top",
-              "inside top",
-              "outside left",
-              "inside left",
-              "outside right",
-              "inside right",
-              "outside bottom",
-              "inside bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "ticklabelstep": {
-            "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
-            "dflt": 1,
-            "editType": "colorbars",
-            "min": 1,
-            "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "ticklen": {
-            "description": "Sets the tick length (in px).",
-            "dflt": 5,
-            "editType": "colorbars",
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattermap'))"
           },
-          "tickmode": {
-            "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
-            "editType": "colorbars",
+          "colorscale": {
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "dflt": null,
+            "editType": "calc",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "autocolorscale": false,
+              "magic_underscores": "fig.update_traces(marker_colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "valType": "enumerated",
-            "values": [
-              "auto",
-              "linear",
-              "array"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "tickprefix": {
-            "description": "Sets a tick label prefix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "ticks": {
-            "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "outside",
-              "inside",
-              ""
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "ticksuffix": {
-            "description": "Sets a tick label suffix.",
-            "dflt": "",
-            "editType": "colorbars",
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "ticktext": {
-            "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
-          "tickvals": {
-            "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
-            "editType": "colorbars",
-            "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+            "valType": "colorscale",
+            "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "tickwidth": {
-            "description": "Sets the tick width (in px).",
-            "dflt": 1,
-            "editType": "colorbars",
+          "editType": "calc",
+          "opacity": {
+            "arrayOk": true,
+            "description": "Sets the marker opacity.",
+            "editType": "calc",
+            "max": 1,
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "title": {
-            "editType": "colorbars",
-            "font": {
-              "color": {
-                "editType": "colorbars",
-                "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "description": "Sets this color bar's title font.",
-              "editType": "colorbars",
-              "family": {
-                "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
-                "editType": "colorbars",
-                "noBlank": true,
-                "strict": true,
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "lineposition": {
-                "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "extras": [
-                  "none"
-                ],
-                "flags": [
-                  "under",
-                  "over",
-                  "through"
-                ],
-                "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "role": "object",
-              "shadow": {
-                "description": "Sets the shape and color of the shadow behind text. *auto* places minimal shadow and applies contrast text font color. See https://developer.mozilla.org/en-US/docs/Web/CSS/text-shadow for additional options.",
-                "dflt": "none",
-                "editType": "colorbars",
-                "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "size": {
-                "editType": "colorbars",
-                "min": 1,
-                "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "style": {
-                "description": "Sets whether a font should be styled with a normal or italic face from its family.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "italic"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "textcase": {
-                "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "word caps",
-                  "upper",
-                  "lower"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "variant": {
-                "description": "Sets the variant of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "valType": "enumerated",
-                "values": [
-                  "normal",
-                  "small-caps",
-                  "all-small-caps",
-                  "all-petite-caps",
-                  "petite-caps",
-                  "unicase"
-                ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "weight": {
-                "description": "Sets the weight (or boldness) of the font.",
-                "dflt": "normal",
-                "editType": "colorbars",
-                "extras": [
-                  "normal",
-                  "bold"
-                ],
-                "max": 1000,
-                "min": 1,
-                "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-              },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='choroplethmapbox'))"
-            },
-            "role": "object",
-            "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
-              "editType": "colorbars",
-              "valType": "enumerated",
-              "values": [
-                "right",
-                "top",
-                "bottom"
-              ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "text": {
-              "description": "Sets the title of the color bar.",
-              "editType": "colorbars",
-              "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "x": {
-            "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "reversescale": {
+            "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_reversescale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "xanchor": {
-            "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "left",
-              "center",
-              "right"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "role": "object",
+          "showscale": {
+            "description": "Determines whether or not a colorbar is displayed for this trace. Has an effect only if in `marker.color` is set to a numerical array.",
+            "dflt": false,
+            "editType": "calc",
+            "valType": "boolean",
+            "magic_underscores": "fig.update_traces(marker_showscale=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "xpad": {
-            "description": "Sets the amount of padding (in px) along the x direction.",
-            "dflt": 10,
-            "editType": "colorbars",
+          "size": {
+            "arrayOk": true,
+            "description": "Sets the marker size (in px).",
+            "dflt": 6,
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "xref": {
-            "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "container",
-              "paper"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "y": {
-            "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
-            "editType": "colorbars",
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "yanchor": {
-            "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
-            "editType": "colorbars",
-            "valType": "enumerated",
-            "values": [
-              "top",
-              "middle",
-              "bottom"
-            ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(marker_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "ypad": {
-            "description": "Sets the amount of padding (in px) along the y direction.",
-            "dflt": 10,
-            "editType": "colorbars",
+          "sizemin": {
+            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the minimum size (in px) of the rendered marker points.",
+            "dflt": 0,
+            "editType": "calc",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(marker_sizemin=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "yref": {
-            "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
-            "dflt": "paper",
-            "editType": "colorbars",
+          "sizemode": {
+            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the rule for which the data in `size` is converted to pixels.",
+            "dflt": "diameter",
+            "editType": "calc",
             "valType": "enumerated",
             "values": [
-              "container",
-              "paper"
+              "diameter",
+              "area"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(marker_sizemode=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='choroplethmapbox'))"
-        },
-        "autocolorscale": {
-          "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "sizeref": {
+            "description": "Has an effect only if `marker.size` is set to a numerical array. Sets the scale factor used to determine the rendered size of marker points. Use with `sizemin` and `sizemode`.",
+            "dflt": 1,
+            "editType": "calc",
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "symbol": {
+            "arrayOk": true,
+            "description": "Sets the marker symbol. Full list: https://www.mapbox.com/maki-icons/ Note that the array `marker.color` and `marker.size` are only available for *circle* symbols.",
+            "dflt": "circle",
+            "editType": "calc",
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "showscale": {
-          "description": "Determines whether or not a colorbar is displayed for this trace.",
-          "dflt": true,
-          "editType": "calc",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "reversescale": {
-          "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
-          "dflt": false,
-          "editType": "plot",
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattermap'))"
         },
-        "zauto": {
-          "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
-          "dflt": true,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+        "line": {
+          "color": {
+            "description": "Sets the line color.",
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(line_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "valType": "boolean",
-          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "zmax": {
-          "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
-          "dflt": null,
           "editType": "calc",
-          "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "role": "object",
+          "width": {
+            "description": "Sets the line width (in px).",
+            "dflt": 2,
+            "editType": "calc",
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(line_width=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(line=dict(...), selector=dict(type='scattermap'))"
         },
-        "zmid": {
-          "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
-          "dflt": null,
-          "editType": "calc",
-          "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+        "textfont": {
+          "color": {
+            "editType": "calc",
+            "valType": "color",
+            "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "zmin": {
-          "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
-          "dflt": null,
+          "description": "Sets the icon text font (color=map.layer.paint.text-color, size=map.layer.layout.text-size). Has an effect only when `type` is set to *symbol*.",
           "editType": "calc",
-          "impliedEdits": {
-            "zauto": false,
-            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "family": {
+            "description": "HTML font family - the typeface that will be applied by the web browser. The web browser can only apply a font if it is available on the system where it runs. Provide multiple font families, separated by commas, to indicate the order in which to apply fonts if they aren't available.",
+            "dflt": "Open Sans Regular, Arial Unicode MS Regular",
+            "editType": "calc",
+            "noBlank": true,
+            "strict": true,
+            "valType": "string",
+            "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "role": "object",
+          "size": {
+            "editType": "calc",
+            "min": 1,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "style": {
+            "description": "Sets whether a font should be styled with a normal or italic face from its family.",
+            "dflt": "normal",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "normal",
+              "italic"
+            ],
+            "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "weight": {
+            "description": "Sets the weight (or boldness) of the font.",
+            "dflt": "normal",
+            "editType": "calc",
+            "extras": [
+              "normal",
+              "bold"
+            ],
+            "max": 1000,
+            "min": 1,
+            "valType": "integer",
+            "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+          },
+          "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattermap'))"
         },
         "selectedpoints": {
           "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
           "editType": "calc",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "selected": {
-          "editType": "plot",
+          "editType": "calc",
           "marker": {
-            "editType": "plot",
+            "color": {
+              "description": "Sets the marker color of selected points.",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(selected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "editType": "calc",
             "opacity": {
               "description": "Sets the marker opacity of selected points.",
-              "editType": "plot",
+              "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='choroplethmapbox'))"
+            "size": {
+              "description": "Sets the marker size of selected points.",
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(selected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='scattermap'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='scattermap'))"
         },
         "unselected": {
-          "editType": "plot",
+          "editType": "calc",
           "marker": {
-            "editType": "plot",
+            "color": {
+              "description": "Sets the marker color of unselected points, applied only when a selection exists.",
+              "editType": "calc",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(unselected_marker_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "editType": "calc",
             "opacity": {
               "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
-              "editType": "plot",
+              "editType": "calc",
               "max": 1,
               "min": 0,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='choroplethmapbox'))"
+            "size": {
+              "description": "Sets the marker size of unselected points, applied only when a selection exists.",
+              "editType": "calc",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(unselected_marker_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+            },
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='scattermap'))"
           },
           "role": "object",
-          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='scattermap'))"
         },
         "below": {
-          "description": "Determines if the choropleth polygons will be inserted before the layer with the specified ID. By default, choroplethmapbox traces are placed above the water layers. If set to '', the layer will be inserted above every existing layer.",
-          "editType": "plot",
+          "description": "Determines if this scattermap trace's layers are to be inserted before the layer with the specified ID. By default, scattermap layers are inserted above all the base layers. To place the scattermap layers above every other layer, set `below` to *''*.",
+          "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "connectgaps": {
+          "description": "Determines whether or not gaps (i.e. {nan} or missing values) in the provided data arrays are connected.",
+          "dflt": false,
+          "editType": "calc",
+          "valType": "boolean",
+          "magic_underscores": "fig.update_traces(connectgaps=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "fill": {
+          "description": "Sets the area to fill with a solid color. Use with `fillcolor` if not *none*. *toself* connects the endpoints of the trace (or each segment of the trace if it has gaps) into a closed shape.",
+          "dflt": "none",
+          "editType": "calc",
+          "valType": "enumerated",
+          "values": [
+            "none",
+            "toself"
+          ],
+          "magic_underscores": "fig.update_traces(fill=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
+        },
+        "fillcolor": {
+          "description": "Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.",
+          "editType": "calc",
+          "valType": "color",
+          "magic_underscores": "fig.update_traces(fillcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
         "hoverlabel": {
           "align": {
@@ -74861,36 +65277,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
           "editType": "none",
           "font": {
@@ -74898,12 +65299,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -74914,12 +65310,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -74935,12 +65326,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "role": "object",
             "shadow": {
@@ -74949,24 +65335,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "style": {
               "arrayOk": true,
@@ -74978,12 +65354,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -74997,12 +65368,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "variant": {
               "arrayOk": true,
@@ -75018,12 +65384,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
             "weight": {
               "arrayOk": true,
@@ -75037,14 +65398,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattermap'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -75053,12 +65409,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
           "role": "object",
           "showarrow": {
@@ -75066,67 +65417,46 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='scattermap'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='choroplethmapbox'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='choroplethmapbox'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattermap'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='choroplethmapbox'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='scattermap'))"
       },
       "categories": [
-        "mapbox",
+        "map",
         "gl",
-        "noOpacity",
-        "showLegend"
+        "symbols",
+        "showLegend",
+        "scatter-like"
       ],
       "meta": {
-        "description": "*choroplethmapbox* trace is deprecated! Please consider switching to the *choroplethmap* trace type and `map` subplots. Learn more at: https://plotly.com/python/maplibre-migration/ as well as https://plotly.com/javascript/maplibre-migration/ GeoJSON features to be filled are set in `geojson` The data that describes the choropleth value-to-color mapping is set in `locations` and `z`.",
-        "hr_name": "choropleth_mapbox"
+        "description": "The data visualized as scatter point, lines or marker symbols on a MapLibre GL geographic map is provided by longitude/latitude pairs in `lon` and `lat`.",
+        "hrName": "scatter_map"
       },
-      "type": "choroplethmapbox"
+      "type": "scattermap"
     },
-    "densitymap": {
+    "choroplethmap": {
       "animatable": false,
       "attributes": {
-        "type": "densitymap",
+        "type": "choroplethmap",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -75138,35 +65468,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": false,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -75174,7 +65504,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -75184,7 +65514,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -75199,7 +65529,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "role": "object",
             "shadow": {
@@ -75207,13 +65537,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -75224,7 +65554,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -75237,7 +65567,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -75252,7 +65582,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -75265,9 +65595,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='choroplethmap'))"
           },
           "role": "object",
           "text": {
@@ -75275,184 +65605,117 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='choroplethmap'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "opacity": {
-          "description": "Sets the opacity of the trace.",
-          "dflt": 1,
-          "editType": "style",
-          "max": 1,
-          "min": 0,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "z": {
-          "description": "Sets the points' weight. For example, a value of 10 would be equivalent to having 10 points of weight 1 in the same spot",
+          "description": "Sets the color values.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
-        "radius": {
-          "arrayOk": true,
-          "description": "Sets the radius of influence of one `lon` / `lat` point in pixels. Increasing the value makes the densitymap trace smoother, but less detailed.",
-          "dflt": 30,
-          "editType": "plot",
-          "min": 1,
-          "valType": "number",
-          "magic_underscores": "fig.update_traces(radius=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "radiussrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `radius`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
-        "lat": {
-          "description": "Sets the latitude coordinates (in degrees North).",
+        "geojson": {
+          "description": "Sets the GeoJSON data associated with this trace. It can be set as a valid GeoJSON object or as a URL string. Note that we only accept GeoJSONs of type *FeatureCollection* or *Feature* with geometries of type *Polygon* or *MultiPolygon*.",
           "editType": "calc",
-          "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(geojson=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
-        "latsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lat`.",
-          "editType": "none",
-          "valType": "string"
+        "featureidkey": {
+          "description": "Sets the key in GeoJSON features which is used as id to match the items included in the `locations` array. Support nested property, for example *properties.name*.",
+          "dflt": "id",
+          "editType": "calc",
+          "valType": "string",
+          "magic_underscores": "fig.update_traces(featureidkey=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
-        "lon": {
-          "description": "Sets the longitude coordinates (in degrees East).",
+        "locations": {
+          "description": "Sets which features found in *geojson* to plot using their feature `id` field.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "lonsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lon`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(locations=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "text": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "description": "Sets the text elements associated with each location.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "hovertext": {
           "arrayOk": true,
-          "description": "Sets hover text elements associated with each (lon,lat) pair If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (lon,lat) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "description": "Same as `text`.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
-          "editType": "none",
+          "editType": "calc",
           "extras": [
             "all",
             "none",
             "skip"
           ],
           "flags": [
-            "lon",
-            "lat",
+            "location",
             "z",
             "text",
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "hovertemplate": {
           "arrayOk": true,
-          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
+          "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variable `properties` Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "subplot": {
           "description": "Sets a reference between this trace's data coordinates and a map subplot. If *map* (the default value), the data refer to `layout.map`. If *map2*, the data refer to `layout.map2`, and so on.",
           "dflt": "map",
           "editType": "calc",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "coloraxis": {
           "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -75460,7 +65723,44 @@
           "editType": "calc",
           "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+        },
+        "marker": {
+          "editType": "calc",
+          "line": {
+            "color": {
+              "arrayOk": true,
+              "description": "Sets the marker.line color. It accepts either a specific color or an array of numbers that are mapped to the colorscale relative to the max and min values of the array or relative to `marker.line.cmin` and `marker.line.cmax` if set.",
+              "dflt": "#444",
+              "editType": "plot",
+              "valType": "color",
+              "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            },
+            "editType": "calc",
+            "role": "object",
+            "width": {
+              "arrayOk": true,
+              "description": "Sets the width (in px) of the lines bounding the marker points.",
+              "dflt": 1,
+              "editType": "plot",
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            },
+            "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='choroplethmap'))"
+          },
+          "opacity": {
+            "arrayOk": true,
+            "description": "Sets the opacity of the locations.",
+            "dflt": 1,
+            "editType": "plot",
+            "max": 1,
+            "min": 0,
+            "valType": "number",
+            "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='choroplethmap'))"
         },
         "colorbar": {
           "bgcolor": {
@@ -75468,14 +65768,14 @@
             "dflt": "rgba(0,0,0,0)",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "bordercolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "borderwidth": {
             "description": "Sets the width (in px) or the border enclosing this color bar.",
@@ -75483,17 +65783,17 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "dtick": {
             "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
             "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "editType": "colorbars",
           "exponentformat": {
@@ -75510,14 +65810,14 @@
               "B",
               "SI extended"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "labelalias": {
             "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
             "dflt": false,
             "editType": "colorbars",
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "len": {
             "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
@@ -75525,7 +65825,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "lenmode": {
             "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
@@ -75536,7 +65836,7 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "minexponent": {
             "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
@@ -75544,7 +65844,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "nticks": {
             "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
@@ -75552,7 +65852,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "orientation": {
             "description": "Sets the orientation of the colorbar.",
@@ -75563,14 +65863,14 @@
               "h",
               "v"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "outlinecolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "outlinewidth": {
             "description": "Sets the width (in px) of the axis line.",
@@ -75578,7 +65878,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "role": "object",
           "separatethousands": {
@@ -75586,7 +65886,7 @@
             "dflt": false,
             "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "showexponent": {
             "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
@@ -75599,14 +65899,14 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "showticklabels": {
             "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
             "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "showtickprefix": {
             "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
@@ -75619,7 +65919,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "showticksuffix": {
             "description": "Same as `showtickprefix` but for tick suffixes.",
@@ -75632,7 +65932,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "thickness": {
             "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
@@ -75640,7 +65940,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "thicknessmode": {
             "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
@@ -75651,37 +65951,37 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tick0": {
             "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
             "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickangle": {
             "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
             "dflt": "auto",
             "editType": "colorbars",
             "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickcolor": {
             "description": "Sets the tick color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickfont": {
             "color": {
               "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "description": "Sets the color bar's tick label font",
             "editType": "colorbars",
@@ -75691,7 +65991,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -75706,7 +66006,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "role": "object",
             "shadow": {
@@ -75714,13 +66014,13 @@
               "dflt": "none",
               "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "size": {
               "editType": "colorbars",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -75731,7 +66031,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -75744,7 +66044,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -75759,7 +66059,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -75772,16 +66072,16 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='choroplethmap'))"
           },
           "tickformat": {
             "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickformatstops": {
             "items": {
@@ -75828,7 +66128,7 @@
               }
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='choroplethmap'))"
           },
           "ticklabeloverflow": {
             "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
@@ -75839,7 +66139,7 @@
               "hide past div",
               "hide past domain"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "ticklabelposition": {
             "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
@@ -75858,7 +66158,7 @@
               "outside bottom",
               "inside bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "ticklabelstep": {
             "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
@@ -75866,7 +66166,7 @@
             "editType": "colorbars",
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "ticklen": {
             "description": "Sets the tick length (in px).",
@@ -75874,13 +66174,13 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickmode": {
             "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
             "editType": "colorbars",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "valType": "enumerated",
             "values": [
@@ -75888,14 +66188,14 @@
               "linear",
               "array"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickprefix": {
             "description": "Sets a tick label prefix.",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "ticks": {
             "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
@@ -75907,36 +66207,26 @@
               "inside",
               ""
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "ticksuffix": {
             "description": "Sets a tick label suffix.",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "ticktext": {
             "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
             "editType": "colorbars",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "colorbars",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
@@ -75944,7 +66234,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "title": {
             "editType": "colorbars",
@@ -75952,7 +66242,7 @@
               "color": {
                 "editType": "colorbars",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "description": "Sets this color bar's title font.",
               "editType": "colorbars",
@@ -75962,7 +66252,7 @@
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -75977,7 +66267,7 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "role": "object",
               "shadow": {
@@ -75985,13 +66275,13 @@
                 "dflt": "none",
                 "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "size": {
                 "editType": "colorbars",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -76002,7 +66292,7 @@
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -76015,7 +66305,7 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
@@ -76030,7 +66320,7 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
@@ -76043,13 +66333,13 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
               },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='choroplethmap'))"
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
@@ -76057,21 +66347,21 @@
                 "top",
                 "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "text": {
               "description": "Sets the title of the color bar.",
               "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='choroplethmap'))"
           },
           "x": {
             "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
             "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "xanchor": {
             "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
@@ -76082,7 +66372,7 @@
               "center",
               "right"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "xpad": {
             "description": "Sets the amount of padding (in px) along the x direction.",
@@ -76090,7 +66380,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "xref": {
             "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
@@ -76101,13 +66391,13 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "y": {
             "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
             "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "yanchor": {
             "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
@@ -76118,7 +66408,7 @@
               "middle",
               "bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "ypad": {
             "description": "Sets the amount of padding (in px) along the y direction.",
@@ -76126,7 +66416,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "yref": {
             "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
@@ -76137,54 +66427,54 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='choroplethmap'))"
         },
         "autocolorscale": {
           "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "showscale": {
           "description": "Determines whether or not a colorbar is displayed for this trace.",
           "dflt": true,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "reversescale": {
           "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
           "dflt": false,
           "editType": "plot",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "zauto": {
           "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "zmax": {
           "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
@@ -76192,20 +66482,20 @@
           "editType": "calc",
           "impliedEdits": {
             "zauto": false,
-            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "zmid": {
           "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "zmin": {
           "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
@@ -76213,16 +66503,58 @@
           "editType": "calc",
           "impliedEdits": {
             "zauto": false,
-            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+        },
+        "selectedpoints": {
+          "description": "Array containing integer indices of selected points. Has an effect only for traces that support selections. Note that an empty array means an empty selection where the `unselected` are turned on for all points, whereas, any other non-array values means no selection all where the `selected` and `unselected` styles have no effect.",
+          "editType": "calc",
+          "valType": "any",
+          "magic_underscores": "fig.update_traces(selectedpoints=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+        },
+        "selected": {
+          "editType": "plot",
+          "marker": {
+            "editType": "plot",
+            "opacity": {
+              "description": "Sets the marker opacity of selected points.",
+              "editType": "plot",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(selected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            },
+            "role": "object",
+            "magic_underscores": "fig.update_traces(selected_marker=dict(...), selector=dict(type='choroplethmap'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(selected=dict(...), selector=dict(type='choroplethmap'))"
+        },
+        "unselected": {
+          "editType": "plot",
+          "marker": {
+            "editType": "plot",
+            "opacity": {
+              "description": "Sets the marker opacity of unselected points, applied only when a selection exists.",
+              "editType": "plot",
+              "max": 1,
+              "min": 0,
+              "valType": "number",
+              "magic_underscores": "fig.update_traces(unselected_marker_opacity=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
+            },
+            "role": "object",
+            "magic_underscores": "fig.update_traces(unselected_marker=dict(...), selector=dict(type='choroplethmap'))"
+          },
+          "role": "object",
+          "magic_underscores": "fig.update_traces(unselected=dict(...), selector=dict(type='choroplethmap'))"
         },
         "below": {
-          "description": "Determines if the densitymap trace will be inserted before the layer with the specified ID. By default, densitymap traces are placed below the first layer of type symbol If set to '', the layer will be inserted above every existing layer.",
+          "description": "Determines if the choropleth polygons will be inserted before the layer with the specified ID. By default, choroplethmap traces are placed above the water layers. If set to '', the layer will be inserted above every existing layer.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
         "hoverlabel": {
           "align": {
@@ -76236,36 +66568,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "editType": "none",
           "font": {
@@ -76273,12 +66590,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -76289,12 +66601,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -76310,12 +66617,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "role": "object",
             "shadow": {
@@ -76324,24 +66626,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "style": {
               "arrayOk": true,
@@ -76353,12 +66645,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -76372,12 +66659,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "variant": {
               "arrayOk": true,
@@ -76393,12 +66675,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
             "weight": {
               "arrayOk": true,
@@ -76412,14 +66689,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='choroplethmap'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -76428,12 +66700,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
           "role": "object",
           "showarrow": {
@@ -76441,66 +66708,45 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='choroplethmap'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='densitymap'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='choroplethmap'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='densitymap'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='choroplethmap'))"
       },
       "categories": [
         "map",
         "gl",
+        "noOpacity",
         "showLegend"
       ],
       "meta": {
-        "description": "Draws a bivariate kernel density estimation with a Gaussian kernel from `lon` and `lat` coordinates and optional `z` values using a colorscale.",
-        "hr_name": "density_map"
+        "description": "GeoJSON features to be filled are set in `geojson` The data that describes the choropleth value-to-color mapping is set in `locations` and `z`.",
+        "hr_name": "choropleth_map"
       },
-      "type": "densitymap"
+      "type": "choroplethmap"
     },
-    "densitymapbox": {
+    "densitymap": {
       "animatable": false,
       "attributes": {
-        "type": "densitymapbox",
+        "type": "densitymap",
         "name": {
           "description": "Sets the trace name. The trace name appears as the legend item and on hover.",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(name=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "uid": {
           "description": "Assign an id to this trace, Use this to provide object constancy between traces during animations and transitions.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(uid=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "visible": {
           "description": "Determines whether or not this trace is visible. If *legendonly*, the trace is not drawn, but can appear as a legend item (provided that the legend itself is visible).",
@@ -76512,35 +66758,35 @@
             false,
             "legendonly"
           ],
-          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(visible=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "showlegend": {
           "description": "Determines whether or not an item corresponding to this trace is shown in the legend.",
           "dflt": false,
           "editType": "style",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(showlegend=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "legend": {
           "description": "Sets the reference to a legend to show this trace in. References to these legends are *legend*, *legend2*, *legend3*, etc. Settings for these legends are set in the layout, under `layout.legend`, `layout.legend2`, etc.",
           "dflt": "legend",
           "editType": "style",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(legend=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "legendrank": {
           "description": "Sets the legend rank for this trace. Items and groups with smaller ranks are presented on top/left side while with *reversed* `legend.traceorder` they are on bottom/right side. The default legendrank is 1000, so that you can use ranks less than 1000 to place certain items before all unranked items, and ranks greater than 1000 to go after all unranked items. When having unranked or equal rank items shapes would be displayed after traces i.e. according to their order in data and layout.",
           "dflt": 1000,
           "editType": "style",
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(legendrank=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "legendgroup": {
           "description": "Sets the legend group for this trace. Traces and shapes part of the same legend group hide/show at the same time when toggling legend items.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(legendgroup=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "legendgrouptitle": {
           "editType": "style",
@@ -76548,7 +66794,7 @@
             "color": {
               "editType": "style",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "description": "Sets this legend group's title font.",
             "editType": "style",
@@ -76558,7 +66804,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -76573,7 +66819,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "role": "object",
             "shadow": {
@@ -76581,13 +66827,13 @@
               "dflt": "none",
               "editType": "style",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "size": {
               "editType": "style",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -76598,7 +66844,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -76611,7 +66857,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -76626,7 +66872,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -76639,9 +66885,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(legendgrouptitle_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
-            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_font=dict(...), selector=dict(type='densitymap'))"
           },
           "role": "object",
           "text": {
@@ -76649,16 +66895,16 @@
             "dflt": "",
             "editType": "style",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(legendgrouptitle_text=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
-          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(legendgrouptitle=dict(...), selector=dict(type='densitymap'))"
         },
         "legendwidth": {
           "description": "Sets the width (in px or fraction) of the legend for this trace.",
           "editType": "style",
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(legendwidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "opacity": {
           "description": "Sets the opacity of the trace.",
@@ -76667,65 +66913,40 @@
           "max": 1,
           "min": 0,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(opacity=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "ids": {
           "description": "Assigns id labels to each datum. These ids for object constancy of data points during animation. Should be an array of strings, not numbers or any other type.",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "z": {
           "description": "Sets the points' weight. For example, a value of 10 would be equivalent to having 10 points of weight 1 in the same spot",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "radius": {
           "arrayOk": true,
-          "description": "Sets the radius of influence of one `lon` / `lat` point in pixels. Increasing the value makes the densitymapbox trace smoother, but less detailed.",
+          "description": "Sets the radius of influence of one `lon` / `lat` point in pixels. Increasing the value makes the densitymap trace smoother, but less detailed.",
           "dflt": 30,
           "editType": "plot",
           "min": 1,
           "valType": "number",
-          "magic_underscores": "fig.update_traces(radius=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "radiussrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `radius`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(radius=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "lat": {
           "description": "Sets the latitude coordinates (in degrees North).",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "latsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lat`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(lat=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "lon": {
           "description": "Sets the longitude coordinates (in degrees East).",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "lonsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `lon`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(lon=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "text": {
           "arrayOk": true,
@@ -76733,12 +66954,7 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "hovertext": {
           "arrayOk": true,
@@ -76746,16 +66962,11 @@
           "dflt": "",
           "editType": "calc",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -76771,12 +66982,7 @@
             "name"
           ],
           "valType": "flaglist",
-          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "hovertemplate": {
           "arrayOk": true,
@@ -76784,49 +66990,34 @@
           "dflt": "",
           "editType": "none",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(hovertemplate=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "hovertemplatefallback": {
           "description": "Fallback string that's displayed when a variable referenced in a template is missing. If the boolean value 'false' is passed in, the specifier with the missing variable will be displayed.",
           "dflt": "-",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
           "editType": "plot",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
-          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
+          "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "subplot": {
-          "description": "mapbox subplots and traces are deprecated! Please consider switching to `map` subplots and traces. Learn more at: https://plotly.com/python/maplibre-migration/ as well as https://plotly.com/javascript/maplibre-migration/ Sets a reference between this trace's data coordinates and a mapbox subplot. If *mapbox* (the default value), the data refer to `layout.mapbox`. If *mapbox2*, the data refer to `layout.mapbox2`, and so on.",
-          "dflt": "mapbox",
+          "description": "Sets a reference between this trace's data coordinates and a map subplot. If *map* (the default value), the data refer to `layout.map`. If *map2*, the data refer to `layout.map2`, and so on.",
+          "dflt": "map",
           "editType": "calc",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(subplot=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "coloraxis": {
           "description": "Sets a reference to a shared color axis. References to these shared color axes are *coloraxis*, *coloraxis2*, *coloraxis3*, etc. Settings for these shared color axes are set in the layout, under `layout.coloraxis`, `layout.coloraxis2`, etc. Note that multiple color scales can be linked to the same color axis.",
@@ -76834,7 +67025,7 @@
           "editType": "calc",
           "regex": "/^coloraxis([2-9]|[1-9][0-9]+)?$/",
           "valType": "subplotid",
-          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(coloraxis=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "colorbar": {
           "bgcolor": {
@@ -76842,14 +67033,14 @@
             "dflt": "rgba(0,0,0,0)",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_bgcolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "bordercolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_bordercolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "borderwidth": {
             "description": "Sets the width (in px) or the border enclosing this color bar.",
@@ -76857,17 +67048,17 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_borderwidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "dtick": {
             "description": "Sets the step in-between ticks on this axis. Use with `tick0`. Must be a positive number, or special strings available to *log* and *date* axes. If the axis `type` is *log*, then ticks are set every 10^(n*dtick) where n is the tick number. For example, to set a tick mark at 1, 10, 100, 1000, ... set dtick to 1. To set tick marks at 1, 100, 10000, ... set dtick to 2. To set tick marks at 1, 5, 25, 125, 625, 3125, ... set dtick to log_10(5), or 0.69897000433. *log* has several special values; *L<f>*, where `f` is a positive number, gives ticks linearly spaced in value (but not position). For example `tick0` = 0.1, `dtick` = *L0.5* will put ticks at 0.1, 0.6, 1.1, 1.6 etc. To show powers of 10 plus small digits between, use *D1* (all digits) or *D2* (only 2 and 5). `tick0` is ignored for *D1* and *D2*. If the axis `type` is *date*, then you must convert the time to milliseconds. For example, to set the interval between ticks to one day, set `dtick` to 86400000.0. *date* also has special values *M<n>* gives ticks spaced by a number of months. `n` must be a positive integer. To set ticks on the 15th of every third month, set `tick0` to *2000-01-15* and `dtick` to *M3*. To set ticks every 4 years, set `dtick` to *M48*",
             "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_dtick_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_dtick=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "editType": "colorbars",
           "exponentformat": {
@@ -76884,14 +67075,14 @@
               "B",
               "SI extended"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_exponentformat=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "labelalias": {
             "description": "Replacement text for specific tick or hover labels. For example using {US: 'USA', CA: 'Canada'} changes US to USA and CA to Canada. The labels we would have shown must match the keys exactly, after adding any tickprefix or ticksuffix. For negative numbers the minus sign symbol used (U+2212) is wider than the regular ascii dash. That means you need to use \u22121 instead of -1. labelalias can be used with any axis type, and both keys (if needed) and values (if desired) can include html-like tags or MathJax.",
             "dflt": false,
             "editType": "colorbars",
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_labelalias=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "len": {
             "description": "Sets the length of the color bar This measure excludes the padding of both ends. That is, the color bar length is this length minus the padding on both ends.",
@@ -76899,7 +67090,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_len=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "lenmode": {
             "description": "Determines whether this color bar's length (i.e. the measure in the color variation direction) is set in units of plot *fraction* or in *pixels. Use `len` to set the value.",
@@ -76910,7 +67101,7 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_lenmode=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "minexponent": {
             "description": "Hide SI prefix for 10^n if |n| is below this number. This only has an effect when `tickformat` is *SI* or *B*.",
@@ -76918,7 +67109,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_minexponent=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "nticks": {
             "description": "Specifies the maximum number of ticks for the particular axis. The actual number of ticks will be chosen automatically to be less than or equal to `nticks`. Has an effect only if `tickmode` is set to *auto*.",
@@ -76926,7 +67117,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_nticks=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "orientation": {
             "description": "Sets the orientation of the colorbar.",
@@ -76937,14 +67128,14 @@
               "h",
               "v"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_orientation=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "outlinecolor": {
             "description": "Sets the axis line color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinecolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "outlinewidth": {
             "description": "Sets the width (in px) of the axis line.",
@@ -76952,7 +67143,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_outlinewidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "role": "object",
           "separatethousands": {
@@ -76960,7 +67151,7 @@
             "dflt": false,
             "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_separatethousands=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "showexponent": {
             "description": "If *all*, all exponents are shown besides their significands. If *first*, only the exponent of the first tick is shown. If *last*, only the exponent of the last tick is shown. If *none*, no exponents appear.",
@@ -76973,14 +67164,14 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_showexponent=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "showticklabels": {
             "description": "Determines whether or not the tick labels are drawn.",
             "dflt": true,
             "editType": "colorbars",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticklabels=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "showtickprefix": {
             "description": "If *all*, all tick labels are displayed with a prefix. If *first*, only the first tick is displayed with a prefix. If *last*, only the last tick is displayed with a suffix. If *none*, tick prefixes are hidden.",
@@ -76993,7 +67184,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_showtickprefix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "showticksuffix": {
             "description": "Same as `showtickprefix` but for tick suffixes.",
@@ -77006,7 +67197,7 @@
               "last",
               "none"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_showticksuffix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "thickness": {
             "description": "Sets the thickness of the color bar This measure excludes the size of the padding, ticks and labels.",
@@ -77014,7 +67205,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_thickness=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "thicknessmode": {
             "description": "Determines whether this color bar's thickness (i.e. the measure in the constant color direction) is set in units of plot *fraction* or in *pixels*. Use `thickness` to set the value.",
@@ -77025,37 +67216,37 @@
               "fraction",
               "pixels"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_thicknessmode=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tick0": {
             "description": "Sets the placement of the first tick on this axis. Use with `dtick`. If the axis `type` is *log*, then you must take the log of your starting tick (e.g. to set the starting tick to 100, set the `tick0` to 2) except when `dtick`=*L<f>* (see `dtick` for more info). If the axis `type` is *date*, it should be a date string, like date data. If the axis `type` is *category*, it should be a number, using the scale where each category is assigned a serial number from zero in the order it appears.",
             "editType": "colorbars",
             "impliedEdits": {
               "tickmode": "linear",
-              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tick0_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "valType": "any",
-            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tick0=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickangle": {
             "description": "Sets the angle of the tick labels with respect to the horizontal. For example, a `tickangle` of -90 draws the tick labels vertically.",
             "dflt": "auto",
             "editType": "colorbars",
             "valType": "angle",
-            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickangle=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickcolor": {
             "description": "Sets the tick color.",
             "dflt": "#444",
             "editType": "colorbars",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickcolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickfont": {
             "color": {
               "editType": "colorbars",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "description": "Sets the color bar's tick label font",
             "editType": "colorbars",
@@ -77065,7 +67256,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "lineposition": {
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -77080,7 +67271,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "role": "object",
             "shadow": {
@@ -77088,13 +67279,13 @@
               "dflt": "none",
               "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "size": {
               "editType": "colorbars",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "style": {
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -77105,7 +67296,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "textcase": {
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -77118,7 +67309,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "variant": {
               "description": "Sets the variant of the font.",
@@ -77133,7 +67324,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "weight": {
               "description": "Sets the weight (or boldness) of the font.",
@@ -77146,16 +67337,16 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickfont_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickfont=dict(...), selector=dict(type='densitymap'))"
           },
           "tickformat": {
             "description": "Sets the tick label formatting rule using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformat=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickformatstops": {
             "items": {
@@ -77202,7 +67393,7 @@
               }
             },
             "role": "object",
-            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickformatstops=list(...), selector=dict(type='densitymap'))"
           },
           "ticklabeloverflow": {
             "description": "Determines how we handle tick labels that would overflow either the graph div or the domain of the axis. The default value for inside tick labels is *hide past domain*. In other cases the default is *hide past div*.",
@@ -77213,7 +67404,7 @@
               "hide past div",
               "hide past domain"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabeloverflow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "ticklabelposition": {
             "description": "Determines where tick labels are drawn relative to the ticks. Left and right options are used when `orientation` is *h*, top and bottom when `orientation` is *v*.",
@@ -77232,7 +67423,7 @@
               "outside bottom",
               "inside bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "ticklabelstep": {
             "description": "Sets the spacing between tick labels as compared to the spacing between ticks. A value of 1 (default) means each tick gets a label. A value of 2 means shows every 2nd label. A larger value n means only every nth tick is labeled. `tick0` determines which labels are shown. Not implemented for axes with `type` *log* or *multicategory*, or when `tickmode` is *array*.",
@@ -77240,7 +67431,7 @@
             "editType": "colorbars",
             "min": 1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklabelstep=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "ticklen": {
             "description": "Sets the tick length (in px).",
@@ -77248,13 +67439,13 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticklen=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickmode": {
             "description": "Sets the tick mode for this axis. If *auto*, the number of ticks is set via `nticks`. If *linear*, the placement of the ticks is determined by a starting position `tick0` and a tick step `dtick` (*linear* is the default value if `tick0` and `dtick` are provided). If *array*, the placement of the ticks is set via `tickvals` and the tick text is `ticktext`. (*array* is the default value if `tickvals` is provided).",
             "editType": "colorbars",
             "impliedEdits": {
-              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_tickmode_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "valType": "enumerated",
             "values": [
@@ -77262,14 +67453,14 @@
               "linear",
               "array"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickmode=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickprefix": {
             "description": "Sets a tick label prefix.",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickprefix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "ticks": {
             "description": "Determines whether ticks are drawn or not. If **, this axis' ticks are not drawn. If *outside* (*inside*), this axis' are drawn outside (inside) the axis lines.",
@@ -77281,36 +67472,26 @@
               "inside",
               ""
             ],
-            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticks=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "ticksuffix": {
             "description": "Sets a tick label suffix.",
             "dflt": "",
             "editType": "colorbars",
             "valType": "string",
-            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_ticksuffix=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "ticktext": {
             "description": "Sets the text displayed at the ticks position via `tickvals`. Only has an effect if `tickmode` is set to *array*. Used with `tickvals`.",
             "editType": "colorbars",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "colorbars",
             "valType": "data_array",
-            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
@@ -77318,7 +67499,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_tickwidth=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "title": {
             "editType": "colorbars",
@@ -77326,7 +67507,7 @@
               "color": {
                 "editType": "colorbars",
                 "valType": "color",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "description": "Sets this color bar's title font.",
               "editType": "colorbars",
@@ -77336,7 +67517,7 @@
                 "noBlank": true,
                 "strict": true,
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "lineposition": {
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -77351,7 +67532,7 @@
                   "through"
                 ],
                 "valType": "flaglist",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "role": "object",
               "shadow": {
@@ -77359,13 +67540,13 @@
                 "dflt": "none",
                 "editType": "colorbars",
                 "valType": "string",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "size": {
                 "editType": "colorbars",
                 "min": 1,
                 "valType": "number",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "style": {
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -77376,7 +67557,7 @@
                   "normal",
                   "italic"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "textcase": {
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -77389,7 +67570,7 @@
                   "upper",
                   "lower"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "variant": {
                 "description": "Sets the variant of the font.",
@@ -77404,7 +67585,7 @@
                   "petite-caps",
                   "unicase"
                 ],
-                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
               "weight": {
                 "description": "Sets the weight (or boldness) of the font.",
@@ -77417,13 +67598,13 @@
                 "max": 1000,
                 "min": 1,
                 "valType": "integer",
-                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+                "magic_underscores": "fig.update_traces(colorbar_title_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
               },
-              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_font=dict(...), selector=dict(type='densitymap'))"
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
@@ -77431,21 +67612,21 @@
                 "top",
                 "bottom"
               ],
-              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_side=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "text": {
               "description": "Sets the title of the color bar.",
               "editType": "colorbars",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+              "magic_underscores": "fig.update_traces(colorbar_title_text=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
-            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_title=dict(...), selector=dict(type='densitymap'))"
           },
           "x": {
             "description": "Sets the x position with respect to `xref` of the color bar (in plot fraction). When `xref` is *paper*, defaults to 1.02 when `orientation` is *v* and 0.5 when `orientation` is *h*. When `xref` is *container*, defaults to *1* when `orientation` is *v* and 0.5 when `orientation` is *h*. Must be between *0* and *1* if `xref` is *container* and between *-2* and *3* if `xref` is *paper*.",
             "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_x=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "xanchor": {
             "description": "Sets this color bar's horizontal position anchor. This anchor binds the `x` position to the *left*, *center* or *right* of the color bar. Defaults to *left* when `orientation` is *v* and *center* when `orientation` is *h*.",
@@ -77456,7 +67637,7 @@
               "center",
               "right"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_xanchor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "xpad": {
             "description": "Sets the amount of padding (in px) along the x direction.",
@@ -77464,7 +67645,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_xpad=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "xref": {
             "description": "Sets the container `x` refers to. *container* spans the entire `width` of the plot. *paper* refers to the width of the plotting area only.",
@@ -77475,13 +67656,13 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_xref=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "y": {
             "description": "Sets the y position with respect to `yref` of the color bar (in plot fraction). When `yref` is *paper*, defaults to 0.5 when `orientation` is *v* and 1.02 when `orientation` is *h*. When `yref` is *container*, defaults to 0.5 when `orientation` is *v* and 1 when `orientation` is *h*. Must be between *0* and *1* if `yref` is *container* and between *-2* and *3* if `yref` is *paper*.",
             "editType": "colorbars",
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_y=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "yanchor": {
             "description": "Sets this color bar's vertical position anchor This anchor binds the `y` position to the *top*, *middle* or *bottom* of the color bar. Defaults to *middle* when `orientation` is *v* and *bottom* when `orientation` is *h*.",
@@ -77492,7 +67673,7 @@
               "middle",
               "bottom"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_yanchor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "ypad": {
             "description": "Sets the amount of padding (in px) along the y direction.",
@@ -77500,7 +67681,7 @@
             "editType": "colorbars",
             "min": 0,
             "valType": "number",
-            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_ypad=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "yref": {
             "description": "Sets the container `y` refers to. *container* spans the entire `height` of the plot. *paper* refers to the height of the plotting area only.",
@@ -77511,54 +67692,54 @@
               "container",
               "paper"
             ],
-            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorbar_yref=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
-          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(colorbar=dict(...), selector=dict(type='densitymap'))"
         },
         "autocolorscale": {
           "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `colorscale`. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(autocolorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
             "autocolorscale": false,
-            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(colorscale_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "valType": "colorscale",
-          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(colorscale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "showscale": {
           "description": "Determines whether or not a colorbar is displayed for this trace.",
           "dflt": true,
           "editType": "calc",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(showscale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "reversescale": {
           "description": "Reverses the color mapping if true. If true, `zmin` will correspond to the last color in the array and `zmax` will correspond to the first color.",
           "dflt": false,
           "editType": "plot",
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(reversescale=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "zauto": {
           "description": "Determines whether or not the color domain is computed with respect to the input data (here in `z`) or the bounds set in `zmin` and `zmax` Defaults to `false` when `zmin` and `zmax` are set by the user.",
           "dflt": true,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(zauto_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "valType": "boolean",
-          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(zauto=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "zmax": {
           "description": "Sets the upper bound of the color domain. Value should have the same units as in `z` and if set, `zmin` must be set as well.",
@@ -77566,20 +67747,20 @@
           "editType": "calc",
           "impliedEdits": {
             "zauto": false,
-            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(zmax_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(zmax=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "zmid": {
           "description": "Sets the mid-point of the color domain by scaling `zmin` and/or `zmax` to be equidistant to this point. Value should have the same units as in `z`. Has no effect when `zauto` is `false`.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
-            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(zmid_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(zmid=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "zmin": {
           "description": "Sets the lower bound of the color domain. Value should have the same units as in `z` and if set, `zmax` must be set as well.",
@@ -77587,16 +67768,16 @@
           "editType": "calc",
           "impliedEdits": {
             "zauto": false,
-            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(zmin_impliedEdits=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "valType": "number",
-          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(zmin=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "below": {
-          "description": "Determines if the densitymapbox trace will be inserted before the layer with the specified ID. By default, densitymapbox traces are placed below the first layer of type symbol If set to '', the layer will be inserted above every existing layer.",
+          "description": "Determines if the densitymap trace will be inserted before the layer with the specified ID. By default, densitymap traces are placed below the first layer of type symbol If set to '', the layer will be inserted above every existing layer.",
           "editType": "plot",
           "valType": "string",
-          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(below=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
         "hoverlabel": {
           "align": {
@@ -77610,36 +67791,21 @@
               "right",
               "auto"
             ],
-            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
             "editType": "none",
             "valType": "color",
-            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "editType": "none",
           "font": {
@@ -77647,12 +67813,7 @@
               "arrayOk": true,
               "editType": "none",
               "valType": "color",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
@@ -77663,12 +67824,7 @@
               "noBlank": true,
               "strict": true,
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "lineposition": {
               "arrayOk": true,
@@ -77684,12 +67840,7 @@
                 "through"
               ],
               "valType": "flaglist",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "role": "object",
             "shadow": {
@@ -77698,24 +67849,14 @@
               "dflt": "none",
               "editType": "none",
               "valType": "string",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "size": {
               "arrayOk": true,
               "editType": "none",
               "min": 1,
               "valType": "number",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "style": {
               "arrayOk": true,
@@ -77727,12 +67868,7 @@
                 "normal",
                 "italic"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "textcase": {
               "arrayOk": true,
@@ -77746,12 +67882,7 @@
                 "upper",
                 "lower"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "variant": {
               "arrayOk": true,
@@ -77767,12 +67898,7 @@
                 "petite-caps",
                 "unicase"
               ],
-              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
             "weight": {
               "arrayOk": true,
@@ -77786,14 +67912,9 @@
               "max": 1000,
               "min": 1,
               "valType": "integer",
-              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-            },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
+              "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
             },
-            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='densitymap'))"
           },
           "namelength": {
             "arrayOk": true,
@@ -77802,12 +67923,7 @@
             "editType": "none",
             "min": -1,
             "valType": "integer",
-            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
+            "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
           "role": "object",
           "showarrow": {
@@ -77815,50 +67931,28 @@
             "dflt": true,
             "editType": "none",
             "valType": "boolean",
-            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
+            "magic_underscores": "fig.update_traces(hoverlabel_showarrow=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
           },
-          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(hoverlabel=dict(...), selector=dict(type='densitymap'))"
         },
         "uirevision": {
           "description": "Controls persistence of some user-driven changes to the trace: `constraintrange` in `parcoords` traces, as well as some `editable: true` modifications such as `name` and `colorbar.title`. Defaults to `layout.uirevision`. Note that other user-driven trace attribute changes are controlled by `layout` attributes: `trace.visible` is controlled by `layout.legend.uirevision`, `selectedpoints` is controlled by `layout.selectionrevision`, and `colorbar.(x|y)` (accessible with `config: {editable: true}`) is controlled by `layout.editrevision`. Trace changes are tracked by `uid`, which only falls back on trace index if no `uid` is provided. So if your app can add/remove traces before the end of the `data` array, such that the same trace has a different index, you can still preserve user-driven changes if you give each trace a `uid` that stays with it as it moves.",
           "editType": "none",
           "valType": "any",
-          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-        },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='densitymapbox'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='densitymapbox'))"
+          "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='densitymap'))"
         },
-        "magic_underscores": "fig.update_traces(..., selector=dict(type='densitymapbox'))"
+        "magic_underscores": "fig.update_traces(..., selector=dict(type='densitymap'))"
       },
       "categories": [
-        "mapbox",
+        "map",
         "gl",
         "showLegend"
       ],
       "meta": {
-        "description": "*densitymapbox* trace is deprecated! Please consider switching to the *densitymap* trace type and `map` subplots. Learn more at: https://plotly.com/python/maplibre-migration/ as well as https://plotly.com/javascript/maplibre-migration/ Draws a bivariate kernel density estimation with a Gaussian kernel from `lon` and `lat` coordinates and optional `z` values using a colorscale.",
-        "hr_name": "density_mapbox"
+        "description": "Draws a bivariate kernel density estimation with a Gaussian kernel from `lon` and `lat` coordinates and optional `z` values using a colorscale.",
+        "hr_name": "density_map"
       },
-      "type": "densitymapbox"
+      "type": "densitymap"
     },
     "scatterpolar": {
       "animatable": false,
@@ -78063,22 +68157,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "r": {
           "description": "Sets the radial coordinates",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(r=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "rsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `r`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "r0": {
           "description": "Alternate to `r`. Builds a linear space of r coordinates. Use with `dr` where `r0` is the starting coordinate and `dr` the step.",
           "dflt": 0,
@@ -78099,11 +68183,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(theta=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "thetasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `theta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "theta0": {
           "description": "Alternate to `theta`. Builds a linear space of theta coordinates. Use with `dtheta` where `theta0` is the starting coordinate and `dtheta` the step.",
           "dflt": 0,
@@ -78137,11 +68216,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
@@ -78161,11 +68235,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `r`, `theta` and `text`.",
@@ -78181,11 +68250,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -78194,14 +68258,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -78218,11 +68277,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -78238,11 +68292,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -78250,22 +68299,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "subplot": {
           "description": "Sets a reference between this trace's data coordinates and a polar subplot. If *polar* (the default value), the data refer to `layout.polar`. If *polar2*, the data refer to `layout.polar2`, and so on.",
           "dflt": "polar",
@@ -78293,11 +68332,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_angleref=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -78825,22 +68859,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -78952,7 +68976,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -79045,7 +69069,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scatterpolar'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -79055,11 +69079,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "gradient": {
             "color": {
@@ -79069,11 +69088,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_gradient_color=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "type": {
@@ -79090,11 +69104,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_gradient_type=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "typesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `type`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_gradient=dict(...), selector=dict(type='scatterpolar'))"
           },
           "line": {
@@ -79166,7 +69175,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -79176,11 +69185,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "dash": {
               "arrayOk": true,
               "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
@@ -79197,11 +69201,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "dashsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -79219,11 +69218,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scatterpolar'))"
           },
           "maxdisplayed": {
@@ -79243,11 +69237,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -79298,11 +69287,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "standoff": {
             "arrayOk": true,
             "description": "Moves the marker away from the data point in the direction of `angle` (in px). This can be useful for example if you have another marker at this location and you want to point an arrowhead marker at it.",
@@ -79312,11 +69296,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_standoff=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "standoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `standoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -79813,11 +69792,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scatterpolar'))"
         },
         "line": {
@@ -79830,11 +69804,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(line_backoff=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "backoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `backoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the line color.",
             "editType": "style",
@@ -79895,11 +69864,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the text font.",
           "editType": "calc",
           "family": {
@@ -79911,11 +69875,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -79932,11 +69891,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -79946,11 +69900,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -79958,11 +69907,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -79975,11 +69919,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -79994,11 +69933,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -80015,11 +69949,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -80034,11 +69963,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scatterpolar'))"
         },
         "selectedpoints": {
@@ -80177,11 +70101,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -80189,11 +70108,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -80201,11 +70115,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -80214,11 +70123,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -80230,11 +70134,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -80251,11 +70150,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -80265,11 +70159,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -80277,11 +70166,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -80294,11 +70178,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -80313,11 +70192,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -80334,11 +70208,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -80353,11 +70222,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scatterpolar'))"
           },
           "namelength": {
@@ -80369,11 +70233,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -80400,28 +70259,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scatterpolar'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scatterpolar'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='scatterpolar'))"
       },
       "categories": [
@@ -80639,22 +70476,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "r": {
           "description": "Sets the radial coordinates",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(r=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "rsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `r`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "r0": {
           "description": "Alternate to `r`. Builds a linear space of r coordinates. Use with `dr` where `r0` is the starting coordinate and `dr` the step.",
           "dflt": 0,
@@ -80675,11 +70502,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(theta=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "thetasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `theta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "theta0": {
           "description": "Alternate to `theta`. Builds a linear space of theta coordinates. Use with `dtheta` where `theta0` is the starting coordinate and `dtheta` the step.",
           "dflt": 0,
@@ -80713,11 +70535,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
@@ -80737,11 +70554,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `r`, `theta` and `text`.",
@@ -80757,11 +70569,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -80770,14 +70577,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -80794,11 +70596,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -80814,11 +70611,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -80826,22 +70618,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "subplot": {
           "description": "Sets a reference between this trace's data coordinates and a polar subplot. If *polar* (the default value), the data refer to `layout.polar`. If *polar2*, the data refer to `layout.polar2`, and so on.",
           "dflt": "polar",
@@ -80858,11 +70640,6 @@
             "valType": "angle",
             "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -81390,22 +71167,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "calc",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -81517,7 +71284,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "calc",
                 "valType": "enumerated",
                 "values": [
@@ -81610,7 +71377,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scatterpolargl'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -81620,11 +71387,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "line": {
             "autocolorscale": {
@@ -81695,7 +71457,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -81705,11 +71467,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -81727,11 +71484,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scatterpolargl'))"
           },
           "opacity": {
@@ -81743,11 +71495,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -81798,11 +71545,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -82299,11 +72041,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scatterpolargl'))"
         },
         "line": {
@@ -82347,11 +72084,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the text font.",
           "editType": "calc",
           "family": {
@@ -82363,11 +72095,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "size": {
             "arrayOk": true,
@@ -82376,11 +72103,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -82393,11 +72115,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -82410,11 +72127,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -82427,11 +72139,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scatterpolargl'))"
         },
         "selectedpoints": {
@@ -82567,11 +72274,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -82579,11 +72281,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -82591,11 +72288,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -82604,11 +72296,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -82620,11 +72307,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -82641,11 +72323,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -82655,11 +72332,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -82667,11 +72339,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -82684,11 +72351,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -82703,11 +72365,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -82724,11 +72381,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -82743,11 +72395,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scatterpolargl'))"
           },
           "namelength": {
@@ -82759,11 +72406,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -82780,28 +72422,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scatterpolargl'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scatterpolargl'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='scatterpolargl'))"
       },
       "categories": [
@@ -83007,11 +72627,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "base": {
           "arrayOk": true,
           "description": "Sets where the bar base is drawn (in radial axis units). In *stack* barmode, traces that set *base* will be excluded and drawn in *overlay* mode instead.",
@@ -83020,22 +72635,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(base=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "basesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `base`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "r": {
           "description": "Sets the radial coordinates",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(r=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "rsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `r`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "r0": {
           "description": "Alternate to `r`. Builds a linear space of r coordinates. Use with `dr` where `r0` is the starting coordinate and `dr` the step.",
           "dflt": 0,
@@ -83056,11 +72661,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(theta=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "thetasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `theta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "theta0": {
           "description": "Alternate to `theta`. Builds a linear space of theta coordinates. Use with `dtheta` where `theta0` is the starting coordinate and `dtheta` the step.",
           "dflt": 0,
@@ -83095,11 +72695,6 @@
           "valType": "number",
           "magic_underscores": "fig.update_traces(width=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "widthsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "offset": {
           "arrayOk": true,
           "description": "Shifts the angular position where the bar is drawn (in *thetatunit* units).",
@@ -83108,11 +72703,6 @@
           "valType": "number",
           "magic_underscores": "fig.update_traces(offset=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "offsetsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `offset`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each bar. If a single string, the same string appears over all bars. If an array of string, the items are mapped in order to the this trace's coordinates.",
@@ -83121,11 +72711,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Same as `text`.",
@@ -83134,14 +72719,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -83158,11 +72738,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -83178,11 +72753,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -83190,22 +72760,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "subplot": {
           "description": "Sets a reference between this trace's data coordinates and a polar subplot. If *polar* (the default value), the data refer to `layout.polar`. If *polar2*, the data refer to `layout.polar2`, and so on.",
           "dflt": "polar",
@@ -83741,22 +73301,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -83868,7 +73418,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -83961,7 +73511,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='barpolar'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -83971,11 +73521,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "line": {
             "autocolorscale": {
@@ -84046,7 +73591,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -84056,11 +73601,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -84079,11 +73619,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='barpolar'))"
           },
           "opacity": {
@@ -84096,11 +73631,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "pattern": {
             "bgcolor": {
               "arrayOk": true,
@@ -84109,11 +73639,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the pattern within the marker.",
             "editType": "style",
             "fgcolor": {
@@ -84123,11 +73648,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "fgopacity": {
               "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
               "editType": "style",
@@ -84154,11 +73674,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shape": {
               "arrayOk": true,
@@ -84178,11 +73693,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
@@ -84192,11 +73702,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "solidity": {
               "arrayOk": true,
               "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
@@ -84207,11 +73712,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='barpolar'))"
           },
           "reversescale": {
@@ -84321,11 +73821,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -84333,11 +73828,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -84345,11 +73835,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -84358,11 +73843,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -84374,11 +73854,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -84395,11 +73870,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -84409,11 +73879,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -84421,11 +73886,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -84438,11 +73898,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -84457,11 +73912,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -84478,11 +73928,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -84497,11 +73942,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='barpolar'))"
           },
           "namelength": {
@@ -84513,11 +73953,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -84534,28 +73969,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='barpolar'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='barpolar'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='barpolar'))"
       },
       "categories": [
@@ -84793,57 +74206,32 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "a": {
           "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary<i>.sum`.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(a=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "asrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `a`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "b": {
           "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary<i>.sum`.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(b=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "bsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `b`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "c": {
           "description": "Sets the quantity of component `a` in each data point. If `a`, `b`, and `c` are all provided, they need not be normalized, only the relative values matter. If only two arrays are provided they must be normalized to match `ternary<i>.sum`.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(c=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "csrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `c`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c). If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "description": "Sets text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the data points in (a,b,c). If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
@@ -84863,11 +74251,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `a`, `b`, `c` and `text`.",
@@ -84883,27 +74266,17 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
-          "description": "Sets hover text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b,c). To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "description": "Sets hover text elements associated with each (a,b,c) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the data points in (a,b,c). To be seen, trace `hoverinfo` must contain a *text* flag.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -84921,11 +74294,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -84941,11 +74309,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -84953,22 +74316,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "subplot": {
           "description": "Sets a reference between this trace's data coordinates and a ternary subplot. If *ternary* (the default value), the data refer to `layout.ternary`. If *ternary2*, the data refer to `layout.ternary2`, and so on.",
           "dflt": "ternary",
@@ -84996,11 +74349,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_angleref=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -85528,22 +74876,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -85655,7 +74993,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -85748,7 +75086,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scatterternary'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -85758,11 +75096,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "gradient": {
             "color": {
@@ -85772,11 +75105,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_gradient_color=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "type": {
@@ -85793,11 +75121,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_gradient_type=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "typesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `type`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_gradient=dict(...), selector=dict(type='scatterternary'))"
           },
           "line": {
@@ -85869,7 +75192,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -85879,11 +75202,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "dash": {
               "arrayOk": true,
               "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
@@ -85900,11 +75218,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "dashsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -85922,11 +75235,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scatterternary'))"
           },
           "maxdisplayed": {
@@ -85946,11 +75254,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -86001,11 +75304,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "standoff": {
             "arrayOk": true,
             "description": "Moves the marker away from the data point in the direction of `angle` (in px). This can be useful for example if you have another marker at this location and you want to point an arrowhead marker at it.",
@@ -86015,11 +75313,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_standoff=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "standoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `standoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -86516,11 +75809,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scatterternary'))"
         },
         "line": {
@@ -86533,11 +75821,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(line_backoff=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "backoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `backoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the line color.",
             "editType": "style",
@@ -86598,11 +75881,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the text font.",
           "editType": "calc",
           "family": {
@@ -86614,11 +75892,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -86635,11 +75908,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -86649,11 +75917,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -86661,11 +75924,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -86678,11 +75936,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -86697,11 +75950,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -86718,11 +75966,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -86737,11 +75980,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scatterternary'))"
         },
         "selectedpoints": {
@@ -86880,11 +76118,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -86892,11 +76125,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -86904,11 +76132,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -86917,11 +76140,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -86933,11 +76151,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -86954,11 +76167,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -86968,11 +76176,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -86980,11 +76183,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -86997,11 +76195,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -87016,11 +76209,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -87037,11 +76225,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -87056,11 +76239,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scatterternary'))"
           },
           "namelength": {
@@ -87072,11 +76250,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -87111,28 +76284,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scatterternary'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scatterternary'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='scatterternary'))"
       },
       "categories": [
@@ -87350,33 +76501,18 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "imag": {
           "description": "Sets the imaginary component of the data, in units of normalized impedance such that real=1, imag=0 is the center of the chart.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(imag=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "imagsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `imag`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "real": {
           "description": "Sets the real component of the data, in units of normalized impedance such that real=1, imag=0 is the center of the chart.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(real=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "realsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `real`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "arrayOk": true,
           "description": "Sets text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
@@ -87385,11 +76521,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
@@ -87409,11 +76540,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `real`, `imag` and `text`.",
@@ -87429,11 +76555,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each (x,y) pair. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -87442,14 +76563,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -87466,11 +76582,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -87486,11 +76597,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -87498,22 +76604,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "subplot": {
           "description": "Sets a reference between this trace's data coordinates and a smith subplot. If *smith* (the default value), the data refer to `layout.smith`. If *smith2*, the data refer to `layout.smith2`, and so on.",
           "dflt": "smith",
@@ -87541,11 +76637,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_angleref=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -88073,22 +77164,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -88200,7 +77281,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -88293,7 +77374,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattersmith'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -88303,11 +77384,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "gradient": {
             "color": {
@@ -88317,11 +77393,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_gradient_color=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "type": {
@@ -88338,11 +77409,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_gradient_type=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "typesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `type`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_gradient=dict(...), selector=dict(type='scattersmith'))"
           },
           "line": {
@@ -88414,7 +77480,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -88424,11 +77490,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "dash": {
               "arrayOk": true,
               "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
@@ -88445,11 +77506,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "dashsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -88467,11 +77523,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scattersmith'))"
           },
           "maxdisplayed": {
@@ -88491,11 +77542,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -88546,11 +77592,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "standoff": {
             "arrayOk": true,
             "description": "Moves the marker away from the data point in the direction of `angle` (in px). This can be useful for example if you have another marker at this location and you want to point an arrowhead marker at it.",
@@ -88560,11 +77601,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_standoff=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "standoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `standoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -89061,11 +78097,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattersmith'))"
         },
         "line": {
@@ -89078,11 +78109,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(line_backoff=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "backoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `backoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the line color.",
             "editType": "style",
@@ -89143,11 +78169,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the text font.",
           "editType": "calc",
           "family": {
@@ -89159,11 +78180,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -89180,11 +78196,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -89194,11 +78205,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -89206,11 +78212,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -89223,11 +78224,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -89242,11 +78238,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -89263,11 +78254,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -89282,11 +78268,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattersmith'))"
         },
         "selectedpoints": {
@@ -89425,11 +78406,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -89437,11 +78413,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -89449,11 +78420,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -89462,11 +78428,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -89478,11 +78439,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -89499,11 +78455,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -89513,11 +78464,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -89525,11 +78471,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -89542,11 +78483,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -89561,11 +78497,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -89582,11 +78513,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -89601,11 +78527,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattersmith'))"
           },
           "namelength": {
@@ -89617,11 +78538,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -89648,28 +78564,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scattersmith'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scattersmith'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='scattersmith'))"
       },
       "categories": [
@@ -89861,55 +78755,30 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "parents": {
           "description": "Sets the parent sectors for each of the sectors. Empty string items '' are understood to reference the root node in the hierarchy. If `ids` is filled, `parents` items are understood to be \"ids\" themselves. When `ids` is not set, plotly attempts to find matching items in `labels`, but beware they must be unique.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(parents=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "parentssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `parents`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "values": {
           "description": "Sets the values associated with each of the sectors. Use with `branchvalues` to determine how the values are summed.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(values=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "valuessrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "labels": {
           "description": "Sets the labels of each of the sectors.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(labels=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "labelssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `labels`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will be seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "editType": "plot",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `currentPath`, `root`, `entry`, `percentRoot`, `percentEntry`, `percentParent`, `label` and `value`.",
@@ -89925,11 +78794,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -89938,14 +78802,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. Flags are rendered in a fixed order; use `hovertemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "dflt": "label+text+value+name",
           "editType": "none",
           "extras": [
@@ -89966,11 +78825,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `currentPath`, `root`, `entry`, `percentRoot`, `percentEntry` and `percentParent`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -89986,11 +78840,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -89998,25 +78847,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this sunburst trace .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this sunburst trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -90026,7 +78865,7 @@
           "editType": "calc",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this sunburst trace .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this sunburst trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -90604,22 +79443,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -90731,7 +79560,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -90830,7 +79659,7 @@
             "magic_underscores": "fig.update_traces(marker_colors=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if colors is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if colors is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -90840,11 +79669,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "colorssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `colors`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "line": {
             "color": {
@@ -90855,11 +79679,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "width": {
@@ -90871,11 +79690,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='sunburst'))"
           },
           "pattern": {
@@ -90886,11 +79700,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the pattern within the marker.",
             "editType": "style",
             "fgcolor": {
@@ -90900,11 +79709,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "fgopacity": {
               "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
               "editType": "style",
@@ -90931,11 +79735,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shape": {
               "arrayOk": true,
@@ -90955,11 +79754,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
@@ -90969,11 +79763,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "solidity": {
               "arrayOk": true,
               "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
@@ -90984,11 +79773,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='sunburst'))"
           },
           "reversescale": {
@@ -91015,11 +79799,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo`.",
           "editType": "plot",
           "family": {
@@ -91031,11 +79810,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -91052,11 +79826,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -91066,11 +79835,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -91078,11 +79842,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -91095,11 +79854,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -91114,11 +79868,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -91135,11 +79884,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -91154,15 +79898,10 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='sunburst'))"
         },
         "textinfo": {
-          "description": "Determines which trace information appear on the graph.",
+          "description": "Determines what trace information appears on the graph. Flags are rendered in a fixed order; use `texttemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "editType": "plot",
           "extras": [
             "none"
@@ -91215,11 +79954,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -91227,11 +79961,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -91239,11 +79968,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -91252,11 +79976,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -91268,11 +79987,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -91289,11 +80003,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -91303,11 +80012,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -91315,11 +80019,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -91332,11 +80031,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -91351,11 +80045,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -91372,11 +80061,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -91391,11 +80075,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='sunburst'))"
           },
           "namelength": {
@@ -91407,11 +80086,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -91429,11 +80103,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying inside the sector.",
           "editType": "plot",
           "family": {
@@ -91445,11 +80114,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -91466,11 +80130,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -91480,11 +80139,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -91492,11 +80146,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -91509,11 +80158,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -91528,11 +80172,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -91549,11 +80188,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -91568,11 +80202,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='sunburst'))"
         },
         "insidetextorientation": {
@@ -91595,11 +80224,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying outside the sector. This option refers to the root of the hierarchy presented at the center of a sunburst graph. Please note that if a hierarchy has multiple root nodes, this option won't have any effect and `insidetextfont` would be used.",
           "editType": "plot",
           "family": {
@@ -91611,11 +80235,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -91632,11 +80251,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -91646,11 +80260,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -91658,11 +80267,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -91675,11 +80279,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -91694,11 +80293,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -91715,11 +80309,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -91734,11 +80323,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='sunburst'))"
         },
         "root": {
@@ -91800,28 +80384,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='sunburst'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='sunburst'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='sunburst'))"
       },
       "categories": [],
@@ -92020,55 +80582,30 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "parents": {
           "description": "Sets the parent sectors for each of the sectors. Empty string items '' are understood to reference the root node in the hierarchy. If `ids` is filled, `parents` items are understood to be \"ids\" themselves. When `ids` is not set, plotly attempts to find matching items in `labels`, but beware they must be unique.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(parents=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "parentssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `parents`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "values": {
           "description": "Sets the values associated with each of the sectors. Use with `branchvalues` to determine how the values are summed.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(values=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "valuessrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "labels": {
           "description": "Sets the labels of each of the sectors.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(labels=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "labelssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `labels`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will be seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "editType": "plot",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "description": "Sets the positions of the `text` elements.",
           "dflt": "top left",
@@ -92102,11 +80639,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -92115,14 +80647,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. Flags are rendered in a fixed order; use `hovertemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "dflt": "label+text+value+name",
           "editType": "none",
           "extras": [
@@ -92143,11 +80670,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `currentPath`, `root`, `entry`, `percentRoot`, `percentEntry` and `percentParent`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -92163,11 +80685,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -92175,25 +80692,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this treemap trace .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this treemap trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -92203,7 +80710,7 @@
           "editType": "calc",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this treemap trace .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this treemap trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -92781,22 +81288,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -92908,7 +81405,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -93007,7 +81504,7 @@
             "magic_underscores": "fig.update_traces(marker_colors=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if colors is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if colors is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -93017,11 +81514,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "colorssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `colors`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "cornerradius": {
             "description": "Sets the maximum rounding of corners (in px).",
             "dflt": 0,
@@ -93051,11 +81543,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "width": {
@@ -93067,11 +81554,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='treemap'))"
           },
           "pad": {
@@ -93115,11 +81597,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the pattern within the marker.",
             "editType": "style",
             "fgcolor": {
@@ -93129,11 +81606,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "fgopacity": {
               "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
               "editType": "style",
@@ -93160,11 +81632,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shape": {
               "arrayOk": true,
@@ -93184,11 +81651,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
@@ -93198,11 +81660,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "solidity": {
               "arrayOk": true,
               "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
@@ -93213,11 +81670,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='treemap'))"
           },
           "reversescale": {
@@ -93244,11 +81696,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo`.",
           "editType": "plot",
           "family": {
@@ -93260,11 +81707,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -93281,11 +81723,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -93295,11 +81732,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -93307,11 +81739,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -93324,11 +81751,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -93343,11 +81765,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -93364,11 +81781,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -93383,15 +81795,10 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='treemap'))"
         },
         "textinfo": {
-          "description": "Determines which trace information appear on the graph.",
+          "description": "Determines what trace information appears on the graph. Flags are rendered in a fixed order; use `texttemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "editType": "plot",
           "extras": [
             "none"
@@ -93495,7 +81902,7 @@
           "editType": "calc",
           "role": "object",
           "side": {
-            "description": "Determines on which side of the the treemap the `pathbar` should be presented.",
+            "description": "Determines on which side of the treemap the `pathbar` should be presented.",
             "dflt": "top",
             "editType": "plot",
             "valType": "enumerated",
@@ -93512,11 +81919,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(pathbar_textfont_color=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used inside `pathbar`.",
             "editType": "plot",
             "family": {
@@ -93528,11 +81930,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(pathbar_textfont_family=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -93549,11 +81946,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(pathbar_textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -93563,11 +81955,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(pathbar_textfont_shadow=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "plot",
@@ -93575,11 +81962,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(pathbar_textfont_size=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -93592,11 +81974,6 @@
               ],
               "magic_underscores": "fig.update_traces(pathbar_textfont_style=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -93611,11 +81988,6 @@
               ],
               "magic_underscores": "fig.update_traces(pathbar_textfont_textcase=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -93632,11 +82004,6 @@
               ],
               "magic_underscores": "fig.update_traces(pathbar_textfont_variant=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -93651,11 +82018,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(pathbar_textfont_weight=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(pathbar_textfont=dict(...), selector=dict(type='treemap'))"
           },
           "thickness": {
@@ -93688,11 +82050,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -93700,11 +82057,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -93712,11 +82064,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -93725,11 +82072,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -93741,11 +82083,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -93762,11 +82099,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -93776,11 +82108,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -93788,11 +82115,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -93805,11 +82127,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -93824,11 +82141,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -93845,11 +82157,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -93864,11 +82171,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='treemap'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='treemap'))"
           },
           "namelength": {
@@ -93880,11 +82182,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -93902,11 +82199,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying inside the sector.",
           "editType": "plot",
           "family": {
@@ -93918,11 +82210,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -93939,11 +82226,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -93953,11 +82235,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -93965,11 +82242,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -93982,11 +82254,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -94001,11 +82268,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -94022,11 +82284,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -94041,11 +82298,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='treemap'))"
         },
         "outsidetextfont": {
@@ -94055,11 +82307,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying outside the sector. This option refers to the root of the hierarchy presented on top left corner of a treemap graph. Please note that if a hierarchy has multiple root nodes, this option won't have any effect and `insidetextfont` would be used.",
           "editType": "plot",
           "family": {
@@ -94071,11 +82318,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -94092,11 +82334,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -94106,11 +82343,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -94118,11 +82350,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -94135,11 +82362,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -94154,11 +82376,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -94175,11 +82392,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -94194,11 +82406,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='treemap'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='treemap'))"
         },
         "root": {
@@ -94240,28 +82447,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='treemap'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='treemap'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='treemap'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='treemap'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='treemap'))"
       },
       "categories": [],
@@ -94460,55 +82645,30 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "parents": {
           "description": "Sets the parent sectors for each of the sectors. Empty string items '' are understood to reference the root node in the hierarchy. If `ids` is filled, `parents` items are understood to be \"ids\" themselves. When `ids` is not set, plotly attempts to find matching items in `labels`, but beware they must be unique.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(parents=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "parentssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `parents`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "values": {
           "description": "Sets the values associated with each of the sectors. Use with `branchvalues` to determine how the values are summed.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(values=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "valuessrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "labels": {
           "description": "Sets the labels of each of the sectors.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(labels=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "labelssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `labels`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "description": "Sets text elements associated with each sector. If trace `textinfo` contains a *text* flag, these elements will be seen on the chart. If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "editType": "plot",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "description": "Sets the positions of the `text` elements.",
           "dflt": "top left",
@@ -94542,11 +82702,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
           "description": "Sets hover text elements associated with each sector. If a single string, the same string appears for all data points. If an array of string, the items are mapped in order of this trace's sectors. To be seen, trace `hoverinfo` must contain a *text* flag.",
@@ -94555,14 +82710,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. Flags are rendered in a fixed order; use `hovertemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "dflt": "label+text+value+name",
           "editType": "none",
           "extras": [
@@ -94583,11 +82733,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `currentPath`, `root`, `entry`, `percentRoot`, `percentEntry` and `percentParent`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -94603,11 +82748,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -94615,25 +82755,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this icicle trace .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this icicle trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -94643,7 +82773,7 @@
           "editType": "calc",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this icicle trace .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this icicle trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -95221,22 +83351,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -95348,7 +83468,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -95447,7 +83567,7 @@
             "magic_underscores": "fig.update_traces(marker_colors=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if colors is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if colors is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -95457,11 +83577,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "colorssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `colors`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "line": {
             "color": {
@@ -95472,11 +83587,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_line_color=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "width": {
@@ -95488,11 +83598,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='icicle'))"
           },
           "pattern": {
@@ -95503,11 +83608,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_bgcolor=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the pattern within the marker.",
             "editType": "style",
             "fgcolor": {
@@ -95517,11 +83617,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_pattern_fgcolor=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "fgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `fgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "fgopacity": {
               "description": "Sets the opacity of the foreground pattern fill. Defaults to a 0.5 when `fillmode` is *overlay*. Otherwise, defaults to 1.",
               "editType": "style",
@@ -95548,11 +83643,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(marker_pattern_path=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "pathsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `path`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shape": {
               "arrayOk": true,
@@ -95572,11 +83662,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_pattern_shape=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "shapesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shape`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "description": "Sets the size of unit squares of the pattern fill in pixels, which corresponds to the interval of repetition of the pattern.",
@@ -95586,11 +83671,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_size=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "solidity": {
               "arrayOk": true,
               "description": "Sets the solidity of the pattern fill. Solidity is roughly the fraction of the area filled by the pattern. Solidity of 0 shows only the background color without pattern and solidty of 1 shows only the foreground color without pattern.",
@@ -95601,11 +83681,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_pattern_solidity=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "soliditysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `solidity`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_pattern=dict(...), selector=dict(type='icicle'))"
           },
           "reversescale": {
@@ -95632,11 +83707,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo`.",
           "editType": "plot",
           "family": {
@@ -95648,11 +83718,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -95669,11 +83734,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -95683,11 +83743,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -95695,11 +83750,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -95712,11 +83762,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -95731,11 +83776,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -95752,11 +83792,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -95771,15 +83806,10 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='icicle'))"
         },
         "textinfo": {
-          "description": "Determines which trace information appear on the graph.",
+          "description": "Determines what trace information appears on the graph. Flags are rendered in a fixed order; use `texttemplate` if you need explicit control over the rendered string, including the order of fields and surrounding text.",
           "editType": "plot",
           "extras": [
             "none"
@@ -95871,7 +83901,7 @@
           "editType": "calc",
           "role": "object",
           "side": {
-            "description": "Determines on which side of the the treemap the `pathbar` should be presented.",
+            "description": "Determines on which side of the treemap the `pathbar` should be presented.",
             "dflt": "top",
             "editType": "plot",
             "valType": "enumerated",
@@ -95888,11 +83918,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(pathbar_textfont_color=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used inside `pathbar`.",
             "editType": "plot",
             "family": {
@@ -95904,11 +83929,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(pathbar_textfont_family=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -95925,11 +83945,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(pathbar_textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -95939,11 +83954,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(pathbar_textfont_shadow=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "plot",
@@ -95951,11 +83961,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(pathbar_textfont_size=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -95968,11 +83973,6 @@
               ],
               "magic_underscores": "fig.update_traces(pathbar_textfont_style=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -95987,11 +83987,6 @@
               ],
               "magic_underscores": "fig.update_traces(pathbar_textfont_textcase=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -96008,11 +84003,6 @@
               ],
               "magic_underscores": "fig.update_traces(pathbar_textfont_variant=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -96027,11 +84017,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(pathbar_textfont_weight=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(pathbar_textfont=dict(...), selector=dict(type='icicle'))"
           },
           "thickness": {
@@ -96064,11 +84049,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -96076,11 +84056,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -96088,11 +84063,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -96101,11 +84071,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -96117,11 +84082,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -96138,11 +84098,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -96152,11 +84107,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -96164,11 +84114,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -96181,11 +84126,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -96200,11 +84140,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -96221,11 +84156,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -96240,11 +84170,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='icicle'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='icicle'))"
           },
           "namelength": {
@@ -96256,11 +84181,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -96278,11 +84198,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(insidetextfont_color=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying inside the sector.",
           "editType": "plot",
           "family": {
@@ -96294,11 +84209,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_family=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -96315,11 +84225,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(insidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -96329,11 +84234,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(insidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -96341,11 +84241,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(insidetextfont_size=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -96358,11 +84253,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_style=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -96377,11 +84267,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -96398,11 +84283,6 @@
             ],
             "magic_underscores": "fig.update_traces(insidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -96417,11 +84297,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(insidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(insidetextfont=dict(...), selector=dict(type='icicle'))"
         },
         "outsidetextfont": {
@@ -96431,11 +84306,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(outsidetextfont_color=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the font used for `textinfo` lying outside the sector. This option refers to the root of the hierarchy presented on top left corner of a treemap graph. Please note that if a hierarchy has multiple root nodes, this option won't have any effect and `insidetextfont` would be used.",
           "editType": "plot",
           "family": {
@@ -96447,11 +84317,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_family=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -96468,11 +84333,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(outsidetextfont_lineposition=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -96482,11 +84342,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(outsidetextfont_shadow=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "plot",
@@ -96494,11 +84349,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(outsidetextfont_size=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -96511,11 +84361,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_style=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -96530,11 +84375,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_textcase=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -96551,11 +84391,6 @@
             ],
             "magic_underscores": "fig.update_traces(outsidetextfont_variant=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -96570,11 +84405,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(outsidetextfont_weight=&lt;VALUE&gt;, selector=dict(type='icicle'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(outsidetextfont=dict(...), selector=dict(type='icicle'))"
         },
         "root": {
@@ -96629,28 +84459,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='icicle'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='icicle'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='icicle'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='icicle'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='icicle'))"
       },
       "categories": [],
@@ -96838,14 +84646,9 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='sankey'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": false,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired. Note that this attribute is superseded by `node.hoverinfo` and `node.hoverinfo` for nodes and links respectively.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired. Note that this attribute is superseded by `node.hoverinfo` and `node.hoverinfo` for nodes and links respectively.",
           "dflt": "all",
           "editType": "calc",
           "extras": [
@@ -96864,25 +84667,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='sankey'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='sankey'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this sankey trace .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this sankey trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -96892,7 +84685,7 @@
           "editType": "calc",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this sankey trace .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this sankey trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -96981,22 +84774,12 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(node_color=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "customdata": {
             "description": "Assigns extra data to each node.",
             "editType": "calc",
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(node_customdata=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "customdatasrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "The nodes of the Sankey plot.",
           "editType": "calc",
           "groups": {
@@ -97017,7 +84800,7 @@
             "magic_underscores": "fig.update_traces(node_groups=list(...), selector=dict(type='sankey'))"
           },
           "hoverinfo": {
-            "description": "Determines which trace information appear when hovering nodes. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+            "description": "Determines what trace information appears when hovering nodes. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
             "dflt": "all",
             "editType": "calc",
             "valType": "enumerated",
@@ -97042,11 +84825,6 @@
               ],
               "magic_underscores": "fig.update_traces(node_hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "alignsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "bgcolor": {
               "arrayOk": true,
               "description": "Sets the background color of the hover labels for this trace",
@@ -97054,11 +84832,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(node_hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "bordercolor": {
               "arrayOk": true,
               "description": "Sets the border color of the hover labels for this trace.",
@@ -97066,11 +84839,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(node_hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "bordercolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "font": {
               "color": {
@@ -97079,11 +84847,6 @@
                 "valType": "color",
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "colorsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "description": "Sets the font used in hover labels.",
               "editType": "calc",
               "family": {
@@ -97095,11 +84858,6 @@
                 "valType": "string",
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "familysrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "lineposition": {
                 "arrayOk": true,
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -97116,11 +84874,6 @@
                 "valType": "flaglist",
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "linepositionsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "role": "object",
               "shadow": {
                 "arrayOk": true,
@@ -97130,11 +84883,6 @@
                 "valType": "string",
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "shadowsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "size": {
                 "arrayOk": true,
                 "editType": "calc",
@@ -97142,11 +84890,6 @@
                 "valType": "number",
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "sizesrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "style": {
                 "arrayOk": true,
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -97159,11 +84902,6 @@
                 ],
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "stylesrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "textcase": {
                 "arrayOk": true,
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -97178,11 +84916,6 @@
                 ],
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "textcasesrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "variant": {
                 "arrayOk": true,
                 "description": "Sets the variant of the font.",
@@ -97199,11 +84932,6 @@
                 ],
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "variantsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "weight": {
                 "arrayOk": true,
                 "description": "Sets the weight (or boldness) of the font.",
@@ -97218,11 +84946,6 @@
                 "valType": "integer",
                 "magic_underscores": "fig.update_traces(node_hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "weightsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "magic_underscores": "fig.update_traces(node_hoverlabel_font=dict(...), selector=dict(type='sankey'))"
             },
             "namelength": {
@@ -97234,11 +84957,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(node_hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "namelengthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "showarrow": {
               "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -97264,11 +84982,6 @@
             "valType": "any",
             "magic_underscores": "fig.update_traces(node_hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "hovertemplatesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "label": {
             "description": "The shown name of the node.",
             "dflt": [],
@@ -97276,11 +84989,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(node_label=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "labelsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `label`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "line": {
             "color": {
               "arrayOk": true,
@@ -97290,11 +84998,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(node_line_color=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "width": {
@@ -97306,11 +85009,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(node_line_width=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(node_line=dict(...), selector=dict(type='sankey'))"
           },
           "pad": {
@@ -97323,6 +85021,17 @@
             "magic_underscores": "fig.update_traces(node_pad=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
           "role": "object",
+          "sort": {
+            "description": "For `auto` (the default), the vertical order of nodes will be determined automatically by the layout. For `input`, the vertical order of nodes is kept the same as the order in the input array.",
+            "dflt": "auto",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "auto",
+              "input"
+            ],
+            "magic_underscores": "fig.update_traces(node_sort=&lt;VALUE&gt;, selector=dict(type='sankey'))"
+          },
           "thickness": {
             "arrayOk": false,
             "description": "Sets the thickness (in px) of the `nodes`.",
@@ -97339,11 +85048,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(node_x=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "xsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "y": {
             "description": "The normalized vertical position of the node.",
             "dflt": [],
@@ -97351,11 +85055,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(node_y=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "ysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(node=dict(...), selector=dict(type='sankey'))"
         },
         "link": {
@@ -97390,7 +85089,7 @@
                   "valType": "number"
                 },
                 "colorscale": {
-                  "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+                  "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `cmin` and `cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
                   "dflt": [
                     [
                       0,
@@ -97430,22 +85129,12 @@
             "role": "object",
             "magic_underscores": "fig.update_traces(link_colorscales=list(...), selector=dict(type='sankey'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "customdata": {
             "description": "Assigns extra data to each link.",
             "editType": "calc",
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(link_customdata=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "customdatasrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "The links of the Sankey plot.",
           "editType": "calc",
           "hovercolor": {
@@ -97455,13 +85144,8 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(link_hovercolor=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "hovercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `hovercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "hoverinfo": {
-            "description": "Determines which trace information appear when hovering links. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+            "description": "Determines what trace information appears when hovering links. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
             "dflt": "all",
             "editType": "calc",
             "valType": "enumerated",
@@ -97486,11 +85170,6 @@
               ],
               "magic_underscores": "fig.update_traces(link_hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "alignsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "bgcolor": {
               "arrayOk": true,
               "description": "Sets the background color of the hover labels for this trace",
@@ -97498,11 +85177,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(link_hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "bgcolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "bordercolor": {
               "arrayOk": true,
               "description": "Sets the border color of the hover labels for this trace.",
@@ -97510,11 +85184,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(link_hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "bordercolorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "font": {
               "color": {
@@ -97523,11 +85192,6 @@
                 "valType": "color",
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "colorsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "description": "Sets the font used in hover labels.",
               "editType": "calc",
               "family": {
@@ -97539,11 +85203,6 @@
                 "valType": "string",
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "familysrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "lineposition": {
                 "arrayOk": true,
                 "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -97560,11 +85219,6 @@
                 "valType": "flaglist",
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "linepositionsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "role": "object",
               "shadow": {
                 "arrayOk": true,
@@ -97574,11 +85228,6 @@
                 "valType": "string",
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "shadowsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "size": {
                 "arrayOk": true,
                 "editType": "calc",
@@ -97586,11 +85235,6 @@
                 "valType": "number",
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "sizesrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "style": {
                 "arrayOk": true,
                 "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -97603,11 +85247,6 @@
                 ],
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "stylesrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "textcase": {
                 "arrayOk": true,
                 "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -97622,11 +85261,6 @@
                 ],
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "textcasesrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "variant": {
                 "arrayOk": true,
                 "description": "Sets the variant of the font.",
@@ -97643,11 +85277,6 @@
                 ],
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "variantsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "weight": {
                 "arrayOk": true,
                 "description": "Sets the weight (or boldness) of the font.",
@@ -97662,11 +85291,6 @@
                 "valType": "integer",
                 "magic_underscores": "fig.update_traces(link_hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='sankey'))"
               },
-              "weightsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "magic_underscores": "fig.update_traces(link_hoverlabel_font=dict(...), selector=dict(type='sankey'))"
             },
             "namelength": {
@@ -97678,11 +85302,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(link_hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "namelengthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "showarrow": {
               "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -97708,11 +85327,6 @@
             "valType": "any",
             "magic_underscores": "fig.update_traces(link_hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "hovertemplatesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "label": {
             "description": "The shown name of the link.",
             "dflt": [],
@@ -97720,11 +85334,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(link_label=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "labelsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `label`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "line": {
             "color": {
               "arrayOk": true,
@@ -97734,11 +85343,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(link_line_color=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "width": {
@@ -97750,14 +85354,20 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(link_line_width=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(link_line=dict(...), selector=dict(type='sankey'))"
           },
           "role": "object",
+          "sort": {
+            "description": "For `auto` (the default), the order of links attached to each node is determined automatically by the layout. For `input`, the order of links at each node is kept the same as the order in the input array.",
+            "dflt": "auto",
+            "editType": "calc",
+            "valType": "enumerated",
+            "values": [
+              "auto",
+              "input"
+            ],
+            "magic_underscores": "fig.update_traces(link_sort=&lt;VALUE&gt;, selector=dict(type='sankey'))"
+          },
           "source": {
             "description": "An integer number `[0..nodes.length - 1]` that represents the source node.",
             "dflt": [],
@@ -97765,11 +85375,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(link_source=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "sourcesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `source`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "target": {
             "description": "An integer number `[0..nodes.length - 1]` that represents the target node.",
             "dflt": [],
@@ -97777,11 +85382,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(link_target=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "targetsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `target`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "value": {
             "description": "A numeric value representing the flow volume value.",
             "dflt": [],
@@ -97789,11 +85389,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(link_value=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "valuesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `value`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(link=dict(...), selector=dict(type='sankey'))"
         },
         "textfont": {
@@ -97928,11 +85523,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -97940,11 +85530,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -97952,11 +85537,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "font": {
             "color": {
@@ -97965,11 +85545,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "calc",
             "family": {
@@ -97981,11 +85556,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -98002,11 +85572,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -98016,11 +85581,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "calc",
@@ -98028,11 +85588,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -98045,11 +85600,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -98064,11 +85614,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -98085,11 +85630,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -98104,11 +85644,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='sankey'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='sankey'))"
           },
           "namelength": {
@@ -98120,11 +85655,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='sankey'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -98155,28 +85685,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='sankey'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='sankey'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='sankey'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='sankey'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='sankey'))"
       },
       "categories": [
@@ -98376,11 +85884,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "arrayOk": true,
           "description": "Sets text elements associated with each (x,y) pair to appear on hover. If a single string, the same string appears over all the data points. If an array of string, the items are mapped in order to the this trace's (x,y) coordinates.",
@@ -98389,11 +85892,6 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "dimensions": {
           "items": {
             "dimension": {
@@ -98401,7 +85899,7 @@
                 "editType": "calc+clearAxisTypes",
                 "matches": {
                   "description": "Determines whether or not the x & y axes generated by this dimension match. Equivalent to setting the `matches` axis attribute in the layout with the correct axis id.",
-                  "dflt": false,
+                  "dflt": true,
                   "editType": "calc",
                   "valType": "boolean"
                 },
@@ -98440,11 +85938,6 @@
                 "editType": "calc+clearAxisTypes",
                 "valType": "data_array"
               },
-              "valuessrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "visible": {
                 "description": "Determines whether or not this dimension is shown on the graph. Note that even visible false dimension contribute to the default grid generate by this splom trace.",
                 "dflt": true,
@@ -98464,14 +85957,9 @@
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -98489,11 +85977,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -98509,20 +85992,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xhoverformat": {
-          "description": "Sets the hover text formatting rulefor `x`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `x` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `xaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
           "magic_underscores": "fig.update_traces(xhoverformat=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
         "yhoverformat": {
-          "description": "Sets the hover text formatting rulefor `y`  using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
+          "description": "Sets the hover text formatting rule for `y` using d3 formatting mini-languages which are very similar to those in Python. For numbers, see: https://github.com/d3/d3-format/tree/v1.4.5#d3-format. And for dates see: https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format. We add two items to d3's date formatter: *%h* for half of the year as a decimal number as well as *%{n}f* for fractional seconds with n digits. For example, *2016-10-13 09:15:23.456* with tickformat *%H~%M~%S.%2f* would display *09~15~23.46*By default the values are formatted using `yaxis.hoverformat`.",
           "dflt": "",
           "editType": "none",
           "valType": "string",
@@ -98535,22 +86013,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "marker": {
           "angle": {
             "arrayOk": true,
@@ -98560,11 +86028,6 @@
             "valType": "angle",
             "magic_underscores": "fig.update_traces(marker_angle=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -99092,22 +86555,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -99219,7 +86672,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -99312,7 +86765,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='splom'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -99322,11 +86775,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "line": {
             "autocolorscale": {
@@ -99397,7 +86845,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -99407,11 +86855,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -99429,11 +86872,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='splom'))"
           },
           "opacity": {
@@ -99445,11 +86883,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -99500,11 +86933,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -100001,11 +87429,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='splom'))"
         },
         "diagonal": {
@@ -100140,11 +87563,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -100152,11 +87570,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -100164,11 +87577,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -100177,11 +87585,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -100193,11 +87596,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -100214,11 +87612,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -100228,11 +87621,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -100240,11 +87628,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -100257,11 +87640,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -100276,11 +87654,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -100297,11 +87670,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -100316,11 +87684,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='splom'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='splom'))"
           },
           "namelength": {
@@ -100332,11 +87695,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='splom'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -100353,28 +87711,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='splom'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='splom'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='splom'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='splom'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='splom'))"
       },
       "categories": [
@@ -100556,11 +87892,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "dimensions": {
           "items": {
             "dimension": {
@@ -100631,31 +87962,16 @@
                 "editType": "plot",
                 "valType": "data_array"
               },
-              "ticktextsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "tickvals": {
                 "description": "Sets the values at which ticks on this axis appear.",
                 "editType": "plot",
                 "valType": "data_array"
               },
-              "tickvalssrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "values": {
                 "description": "Dimension values. `values[n]` represents the value of the `n`th point in the dataset, therefore the `values` vector for all dimensions must be the same (longer vectors will be truncated). Each value must be a finite number.",
                 "editType": "calc",
                 "valType": "data_array"
               },
-              "valuessrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "visible": {
                 "description": "Shows the dimension when set to `true` (the default). Hides the dimension for `false`.",
                 "dflt": true,
@@ -100674,25 +87990,15 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this parcoords trace .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this parcoords trace.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -100702,7 +88008,7 @@
           "editType": "plot",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this parcoords trace .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this parcoords trace.",
             "dflt": 0,
             "editType": "plot",
             "min": 0,
@@ -101287,22 +88593,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(line_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(line_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -101414,7 +88710,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -101507,7 +88803,7 @@
             "magic_underscores": "fig.update_traces(line_colorbar=dict(...), selector=dict(type='parcoords'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": [
               [
                 0,
@@ -101586,11 +88882,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(line_colorscale=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `line.color` is set to a numerical array. If true, `line.cmin` will correspond to the last color in the array and `line.cmax` will correspond to the first color.",
@@ -101956,28 +89247,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='parcoords'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='parcoords'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='parcoords'))"
       },
       "categories": [
@@ -102146,11 +89415,6 @@
           "valType": "number",
           "magic_underscores": "fig.update_traces(counts=&lt;VALUE&gt;, selector=dict(type='parcats'))"
         },
-        "countssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `counts`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "dimensions": {
           "items": {
             "dimension": {
@@ -102159,11 +89423,6 @@
                 "editType": "calc",
                 "valType": "data_array"
               },
-              "categoryarraysrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "categoryorder": {
                 "description": "Specifies the ordering logic for the categories in the dimension. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.",
                 "dflt": "trace",
@@ -102194,22 +89453,12 @@
                 "editType": "calc",
                 "valType": "data_array"
               },
-              "ticktextsrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "values": {
                 "description": "Dimension values. `values[n]` represents the category value of the `n`th point in the dataset, therefore the `values` vector for all dimensions must be the same (longer vectors will be truncated).",
                 "dflt": [],
                 "editType": "calc",
                 "valType": "data_array"
               },
-              "valuessrc": {
-                "description": "Sets the source reference on Chart Studio Cloud for `values`.",
-                "editType": "none",
-                "valType": "string"
-              },
               "visible": {
                 "description": "Shows the dimension when set to `true` (the default). Hides the dimension for `false`.",
                 "dflt": true,
@@ -102223,7 +89472,7 @@
         },
         "hoverinfo": {
           "arrayOk": false,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "plot",
           "extras": [
@@ -102259,14 +89508,9 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='parcats'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "domain": {
           "column": {
-            "description": "If there is a layout grid, use the domain for this column in the grid for this parcats trace .",
+            "description": "If there is a layout grid, use the domain for this column in the grid for this parcats trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -102276,7 +89520,7 @@
           "editType": "calc",
           "role": "object",
           "row": {
-            "description": "If there is a layout grid, use the domain for this row in the grid for this parcats trace .",
+            "description": "If there is a layout grid, use the domain for this row in the grid for this parcats trace.",
             "dflt": 0,
             "editType": "calc",
             "min": 0,
@@ -102861,22 +90105,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(line_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='parcats'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(line_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='parcats'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -102988,7 +90222,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -103081,7 +90315,7 @@
             "magic_underscores": "fig.update_traces(line_colorbar=dict(...), selector=dict(type='parcats'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `line.cmin` and `line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -103091,11 +90325,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(line_colorscale=&lt;VALUE&gt;, selector=dict(type='parcats'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "hovertemplate": {
             "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Finally, the template string has access to variables `count` and `probability`. Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -103385,28 +90614,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='parcats'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='parcats'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='parcats'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='parcats'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='parcats'))"
       },
       "categories": [
@@ -103594,11 +90801,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -103612,33 +90814,18 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(x=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "xsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `x`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "y": {
           "description": "A two dimensional array of y coordinates at each carpet point.",
           "editType": "calc+clearAxisTypes",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(y=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "ysrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `y`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "a": {
           "description": "An array containing values of the first parameter value",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(a=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "asrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `a`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "a0": {
           "description": "Alternate to `a`. Builds a linear space of a coordinates. Use with `da` where `a0` is the starting coordinate and `da` the step.",
           "dflt": 0,
@@ -103659,11 +90846,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(b=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "bsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `b`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "b0": {
           "description": "Alternate to `b`. Builds a linear space of a coordinates. Use with `db` where `b0` is the starting coordinate and `db` the step.",
           "dflt": 0,
@@ -103685,22 +90867,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "aaxis": {
           "arraydtick": {
             "description": "The stride between grid lines along the axis",
@@ -103747,11 +90919,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(aaxis_categoryarray=&lt;VALUE&gt;, selector=dict(type='carpet'))"
           },
-          "categoryarraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "categoryorder": {
             "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.",
             "dflt": "trace",
@@ -104284,22 +91451,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(aaxis_ticktext=&lt;VALUE&gt;, selector=dict(type='carpet'))"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "calc",
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(aaxis_tickvals=&lt;VALUE&gt;, selector=dict(type='carpet'))"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "title": {
             "editType": "calc",
             "font": {
@@ -104479,11 +91636,6 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(baxis_categoryarray=&lt;VALUE&gt;, selector=dict(type='carpet'))"
           },
-          "categoryarraysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `categoryarray`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "categoryorder": {
             "description": "Specifies the ordering logic for the case of categorical variables. By default, plotly uses *trace*, which specifies the order that is present in the data supplied. Set `categoryorder` to *category ascending* or *category descending* if order should be determined by the alphanumerical order of the category names. Set `categoryorder` to *array* to derive the ordering from the attribute `categoryarray`. If a category is not found in the `categoryarray` array, the sorting behavior for that attribute will be identical to the *trace* mode. The unspecified categories will follow the categories in `categoryarray`.",
             "dflt": "trace",
@@ -105016,22 +92168,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(baxis_ticktext=&lt;VALUE&gt;, selector=dict(type='carpet'))"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "calc",
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(baxis_tickvals=&lt;VALUE&gt;, selector=dict(type='carpet'))"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "title": {
             "editType": "calc",
             "font": {
@@ -105307,28 +92449,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='carpet'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='carpet'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='carpet'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='carpet'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='carpet'))"
       },
       "categories": [
@@ -105550,11 +92670,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -105568,35 +92683,20 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(a=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "asrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `a`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "b": {
           "description": "Sets the b-axis coordinates.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(b=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "bsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `b`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "text": {
           "arrayOk": true,
-          "description": "Sets text elements associated with each (a,b) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b). If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
+          "description": "Sets text elements associated with each (a,b) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the data points in (a,b). If trace `hoverinfo` contains a *text* flag and *hovertext* is not set, these elements will be seen in the hover labels.",
           "dflt": "",
           "editType": "calc",
           "valType": "string",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "textposition": {
           "arrayOk": true,
           "description": "Sets the positions of the `text` elements with respects to the (x,y) coordinates.",
@@ -105616,11 +92716,6 @@
           ],
           "magic_underscores": "fig.update_traces(textposition=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "textpositionsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `textposition`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "texttemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information text that appears on points. Note that this will override `textinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\". Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. All attributes that can be specified per-point (the ones that are `arrayOk: true`) are available. Finally, the template string has access to variables `a`, `b` and `text`.",
@@ -105636,27 +92731,17 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(texttemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "texttemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `texttemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "arrayOk": true,
-          "description": "Sets hover text elements associated with each (a,b) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the the data points in (a,b). To be seen, trace `hoverinfo` must contain a *text* flag.",
+          "description": "Sets hover text elements associated with each (a,b) point. If a single string, the same string appears over all the data points. If an array of strings, the items are mapped in order to the data points in (a,b). To be seen, trace `hoverinfo` must contain a *text* flag.",
           "dflt": "",
           "editType": "style",
           "valType": "string",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hoverinfo": {
           "arrayOk": true,
-          "description": "Determines which trace information appear on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
+          "description": "Determines what trace information appears on hover. If `none` or `skip` are set, no information is displayed upon hovering. But, if `none` is set, click and hover events are still fired.",
           "dflt": "all",
           "editType": "none",
           "extras": [
@@ -105673,11 +92758,6 @@
           "valType": "flaglist",
           "magic_underscores": "fig.update_traces(hoverinfo=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "hoverinfosrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hoverinfo`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertemplate": {
           "arrayOk": true,
           "description": "Template string used for rendering the information that appear on hover box. Note that this will override `hoverinfo`. Variables are inserted using %{variable}, for example \"y: %{y}\" as well as %{xother}, {%_xother}, {%_xother_}, {%xother_}. When showing info for several points, *xother* will be added to those with different x positions from the first point. An underscore before or after *(x|y)other* will add a space on that side, only when this field is shown. Numbers are formatted using d3-format's syntax %{variable:d3-format}, for example \"Price: %{y:$.2f}\". https://github.com/d3/d3-format/tree/v1.4.5#d3-format for details on the formatting syntax. Dates are formatted using d3-time-format's syntax %{variable|d3-time-format}, for example \"Day: %{2019-01-01|%A}\". https://github.com/d3/d3-time-format/tree/v2.2.3#locale_format for details on the date formatting syntax. Variables that can't be found will be replaced with the specifier. For example, a template of \"data: %{x}, %{y}\" will result in a value of \"data: 1, %{y}\" if x is 1 and y is missing. Variables with an undefined value will be replaced with the fallback value. The variables available in `hovertemplate` are the ones emitted as event data described at this link https://plotly.com/javascript/plotlyjs-events/#event-data. Additionally, all attributes that can be specified per-point (the ones that are `arrayOk: true`) are available.  Anything contained in tag `<extra>` is displayed in the secondary box, for example `<extra>%{fullData.name}</extra>`. To hide the secondary box completely, use an empty tag `<extra></extra>`.",
@@ -105693,11 +92773,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(hovertemplatefallback=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "hovertemplatesrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertemplate`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -105705,22 +92780,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -105755,11 +92820,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_angleref=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "anglesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `angle`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "autocolorscale": {
             "description": "Determines whether the colorscale is a default palette (`autocolorscale: true`) or the palette determined by `marker.colorscale`. Has an effect only if in `marker.color` is set to a numerical array. In case `colorscale` is unspecified or `autocolorscale` is true, the default palette will be chosen according to whether numbers in the `color` array are all positive, all negative or mixed.",
             "dflt": true,
@@ -106287,22 +93347,12 @@
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "ticktextsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickvals": {
               "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
               "editType": "colorbars",
               "valType": "data_array",
               "magic_underscores": "fig.update_traces(marker_colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "tickvalssrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "tickwidth": {
               "description": "Sets the tick width (in px).",
               "dflt": 1,
@@ -106414,7 +93464,7 @@
               },
               "role": "object",
               "side": {
-                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+                "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
                 "editType": "colorbars",
                 "valType": "enumerated",
                 "values": [
@@ -106507,7 +93557,7 @@
             "magic_underscores": "fig.update_traces(marker_colorbar=dict(...), selector=dict(type='scattercarpet'))"
           },
           "colorscale": {
-            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+            "description": "Sets the colorscale. Has an effect only if in `marker.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.cmin` and `marker.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
             "dflt": null,
             "editType": "calc",
             "impliedEdits": {
@@ -106517,11 +93567,6 @@
             "valType": "colorscale",
             "magic_underscores": "fig.update_traces(marker_colorscale=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "calc",
           "gradient": {
             "color": {
@@ -106531,11 +93576,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(marker_gradient_color=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "role": "object",
             "type": {
@@ -106552,11 +93592,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_gradient_type=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "typesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `type`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_gradient=dict(...), selector=dict(type='scattercarpet'))"
           },
           "line": {
@@ -106628,7 +93663,7 @@
               "magic_underscores": "fig.update_traces(marker_line_coloraxis=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
             "colorscale": {
-              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+              "description": "Sets the colorscale. Has an effect only if in `marker.line.color` is set to a numerical array. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `marker.line.cmin` and `marker.line.cmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
               "dflt": null,
               "editType": "calc",
               "impliedEdits": {
@@ -106638,11 +93673,6 @@
               "valType": "colorscale",
               "magic_underscores": "fig.update_traces(marker_line_colorscale=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "dash": {
               "arrayOk": true,
               "description": "Sets the dash style of lines. Set to a dash type string (*solid*, *dot*, *dash*, *longdash*, *dashdot*, or *longdashdot*) or a dash length list in px (eg *5px,10px,2px,2px*).",
@@ -106659,11 +93689,6 @@
               ],
               "magic_underscores": "fig.update_traces(marker_line_dash=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "dashsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `dash`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "editType": "calc",
             "reversescale": {
               "description": "Reverses the color mapping if true. Has an effect only if in `marker.line.color` is set to a numerical array. If true, `marker.line.cmin` will correspond to the last color in the array and `marker.line.cmax` will correspond to the first color.",
@@ -106681,11 +93706,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(marker_line_width=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "widthsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `width`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(marker_line=dict(...), selector=dict(type='scattercarpet'))"
           },
           "maxdisplayed": {
@@ -106705,11 +93725,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_opacity=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "opacitysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `opacity`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "reversescale": {
             "description": "Reverses the color mapping if true. Has an effect only if in `marker.color` is set to a numerical array. If true, `marker.cmin` will correspond to the last color in the array and `marker.cmax` will correspond to the first color.",
             "dflt": false,
@@ -106760,11 +93775,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_sizeref=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "standoff": {
             "arrayOk": true,
             "description": "Moves the marker away from the data point in the direction of `angle` (in px). This can be useful for example if you have another marker at this location and you want to point an arrowhead marker at it.",
@@ -106774,11 +93784,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(marker_standoff=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "standoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `standoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "symbol": {
             "arrayOk": true,
             "description": "Sets the marker symbol type. Adding 100 is equivalent to appending *-open* to a symbol name. Adding 200 is equivalent to appending *-dot* to a symbol name. Adding 300 is equivalent to appending *-open-dot* or *dot-open* to a symbol name.",
@@ -107275,11 +94280,6 @@
             ],
             "magic_underscores": "fig.update_traces(marker_symbol=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "symbolsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `symbol`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(marker=dict(...), selector=dict(type='scattercarpet'))"
         },
         "line": {
@@ -107292,11 +94292,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(line_backoff=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "backoffsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `backoff`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "color": {
             "description": "Sets the line color.",
             "editType": "style",
@@ -107357,11 +94352,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(textfont_color=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "colorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "description": "Sets the text font.",
           "editType": "calc",
           "family": {
@@ -107373,11 +94363,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_family=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "familysrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "lineposition": {
             "arrayOk": true,
             "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -107394,11 +94379,6 @@
             "valType": "flaglist",
             "magic_underscores": "fig.update_traces(textfont_lineposition=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "linepositionsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "shadow": {
             "arrayOk": true,
@@ -107408,11 +94388,6 @@
             "valType": "string",
             "magic_underscores": "fig.update_traces(textfont_shadow=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "shadowsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "size": {
             "arrayOk": true,
             "editType": "calc",
@@ -107420,11 +94395,6 @@
             "valType": "number",
             "magic_underscores": "fig.update_traces(textfont_size=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "sizesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "style": {
             "arrayOk": true,
             "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -107437,11 +94407,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_style=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "stylesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "textcase": {
             "arrayOk": true,
             "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -107456,11 +94421,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_textcase=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "textcasesrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "variant": {
             "arrayOk": true,
             "description": "Sets the variant of the font.",
@@ -107477,11 +94437,6 @@
             ],
             "magic_underscores": "fig.update_traces(textfont_variant=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "variantsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "weight": {
             "arrayOk": true,
             "description": "Sets the weight (or boldness) of the font.",
@@ -107496,11 +94451,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(textfont_weight=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "weightsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "magic_underscores": "fig.update_traces(textfont=dict(...), selector=dict(type='scattercarpet'))"
         },
         "selectedpoints": {
@@ -107638,11 +94588,6 @@
             ],
             "magic_underscores": "fig.update_traces(hoverlabel_align=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "alignsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `align`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bgcolor": {
             "arrayOk": true,
             "description": "Sets the background color of the hover labels for this trace",
@@ -107650,11 +94595,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bgcolor=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "bgcolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bgcolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "bordercolor": {
             "arrayOk": true,
             "description": "Sets the border color of the hover labels for this trace.",
@@ -107662,11 +94602,6 @@
             "valType": "color",
             "magic_underscores": "fig.update_traces(hoverlabel_bordercolor=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "bordercolorsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `bordercolor`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "editType": "none",
           "font": {
             "color": {
@@ -107675,11 +94610,6 @@
               "valType": "color",
               "magic_underscores": "fig.update_traces(hoverlabel_font_color=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "colorsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `color`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "description": "Sets the font used in hover labels.",
             "editType": "none",
             "family": {
@@ -107691,11 +94621,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_family=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "familysrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `family`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "lineposition": {
               "arrayOk": true,
               "description": "Sets the kind of decoration line(s) with text, such as an *under*, *over* or *through* as well as combinations e.g. *under+over*, etc.",
@@ -107712,11 +94637,6 @@
               "valType": "flaglist",
               "magic_underscores": "fig.update_traces(hoverlabel_font_lineposition=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "linepositionsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `lineposition`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "role": "object",
             "shadow": {
               "arrayOk": true,
@@ -107726,11 +94646,6 @@
               "valType": "string",
               "magic_underscores": "fig.update_traces(hoverlabel_font_shadow=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "shadowsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `shadow`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "size": {
               "arrayOk": true,
               "editType": "none",
@@ -107738,11 +94653,6 @@
               "valType": "number",
               "magic_underscores": "fig.update_traces(hoverlabel_font_size=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "sizesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `size`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "style": {
               "arrayOk": true,
               "description": "Sets whether a font should be styled with a normal or italic face from its family.",
@@ -107755,11 +94665,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_style=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "stylesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `style`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "textcase": {
               "arrayOk": true,
               "description": "Sets capitalization of text. It can be used to make text appear in all-uppercase or all-lowercase, or with each word capitalized.",
@@ -107774,11 +94679,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_textcase=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "textcasesrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `textcase`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "variant": {
               "arrayOk": true,
               "description": "Sets the variant of the font.",
@@ -107795,11 +94695,6 @@
               ],
               "magic_underscores": "fig.update_traces(hoverlabel_font_variant=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "variantsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `variant`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "weight": {
               "arrayOk": true,
               "description": "Sets the weight (or boldness) of the font.",
@@ -107814,11 +94709,6 @@
               "valType": "integer",
               "magic_underscores": "fig.update_traces(hoverlabel_font_weight=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
             },
-            "weightsrc": {
-              "description": "Sets the source reference on Chart Studio Cloud for `weight`.",
-              "editType": "none",
-              "valType": "string"
-            },
             "magic_underscores": "fig.update_traces(hoverlabel_font=dict(...), selector=dict(type='scattercarpet'))"
           },
           "namelength": {
@@ -107830,11 +94720,6 @@
             "valType": "integer",
             "magic_underscores": "fig.update_traces(hoverlabel_namelength=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
           },
-          "namelengthsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `namelength`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "role": "object",
           "showarrow": {
             "description": "Sets whether or not to show the hover label arrow/triangle pointing to the data point.",
@@ -107861,28 +94746,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='scattercarpet'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='scattercarpet'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='scattercarpet'))"
       },
       "categories": [
@@ -108088,11 +94951,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(ids=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "idssrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `ids`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "zorder": {
           "description": "Sets the layer on which this trace is displayed, relative to other SVG traces on the same subplot. SVG traces with higher `zorder` appear in front of those with lower `zorder`.",
           "dflt": 0,
@@ -108106,11 +94964,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(z=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "zsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `z`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "a": {
           "description": "Sets the x coordinates.",
           "editType": "calc+clearAxisTypes",
@@ -108121,11 +94974,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(a=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "asrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `a`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "atype": {
           "description": "If *array*, the heatmap's x coordinates are given by *x* (the default behavior when `x` is provided). If *scaled*, the heatmap's x coordinates are given by *x0* and *dx* (the default behavior when `x` is not provided).",
           "editType": "calc+clearAxisTypes",
@@ -108168,11 +95016,6 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(b=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "bsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `b`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "btype": {
           "description": "If *array*, the heatmap's y coordinates are given by *y* (the default behavior when `y` is provided) If *scaled*, the heatmap's y coordinates are given by *y0* and *dy* (the default behavior when `y` is not provided)",
           "editType": "calc+clearAxisTypes",
@@ -108211,22 +95054,12 @@
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(text=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "textsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `text`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "hovertext": {
           "description": "Same as `text`.",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(hovertext=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "hovertextsrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `hovertext`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "meta": {
           "arrayOk": true,
           "description": "Assigns extra meta information associated with this trace that can be used in various text attributes. Attributes such as trace `name`, graph, axis and colorbar `title.text`, annotation `text` `rangeselector`, `updatemenues` and `sliders` `label` text all support `meta`. To access the trace `meta` values in an attribute in the same trace, simply use `%{meta[i]}` where `i` is the index or key of the `meta` item in question. To access trace `meta` in layout attributes, use `%{data[n[.meta[i]}` where `i` is the index or key of the `meta` and `n` is the trace index.",
@@ -108234,22 +95067,12 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(meta=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "metasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `meta`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "customdata": {
           "description": "Assigns extra data each datum. This may be useful when listening to hover, click and selection events. Note that, *scatter* traces also appends customdata items in the markers DOM elements",
           "editType": "calc",
           "valType": "data_array",
           "magic_underscores": "fig.update_traces(customdata=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "customdatasrc": {
-          "description": "Sets the source reference on Chart Studio Cloud for `customdata`.",
-          "editType": "none",
-          "valType": "string"
-        },
         "xaxis": {
           "description": "Sets a reference between this trace's x coordinates and a 2D cartesian x axis. If *x* (the default value), the x coordinates refer to `layout.xaxis`. If *x2*, the x coordinates refer to `layout.xaxis2`, and so on.",
           "dflt": "x",
@@ -108774,22 +95597,12 @@
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(colorbar_ticktext=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
           },
-          "ticktextsrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `ticktext`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickvals": {
             "description": "Sets the values at which ticks on this axis appear. Only has an effect if `tickmode` is set to *array*. Used with `ticktext`.",
             "editType": "colorbars",
             "valType": "data_array",
             "magic_underscores": "fig.update_traces(colorbar_tickvals=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
           },
-          "tickvalssrc": {
-            "description": "Sets the source reference on Chart Studio Cloud for `tickvals`.",
-            "editType": "none",
-            "valType": "string"
-          },
           "tickwidth": {
             "description": "Sets the tick width (in px).",
             "dflt": 1,
@@ -108901,7 +95714,7 @@
             },
             "role": "object",
             "side": {
-              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` if *v* and  defaults to *right* when `orientation` if *h*.",
+              "description": "Determines the location of color bar's title with respect to the color bar. Defaults to *top* when `orientation` is *v* and defaults to *right* when `orientation` is *h*.",
               "editType": "colorbars",
               "valType": "enumerated",
               "values": [
@@ -109004,7 +95817,7 @@
           "magic_underscores": "fig.update_traces(autocolorscale=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
         "colorscale": {
-          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsv, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
+          "description": "Sets the colorscale. The colorscale must be an array containing arrays mapping a normalized value to an rgb, rgba, hex, hsl, hsla, hwb, or named color string. At minimum, a mapping for the lowest (0) and highest (1) values are required. For example, `[[0, 'rgb(0,0,255)'], [1, 'rgb(255,0,0)']]`. To control the bounds of the colorscale in color space, use `zmin` and `zmax`. Alternatively, `colorscale` may be a palette name string of the following list: Blackbody,Bluered,Blues,Cividis,Earth,Electric,Greens,Greys,Hot,Jet,Picnic,Portland,Rainbow,RdBu,Reds,Viridis,YlGnBu,YlOrRd.",
           "dflt": null,
           "editType": "calc",
           "impliedEdits": {
@@ -109223,7 +96036,7 @@
             "magic_underscores": "fig.update_traces(contours_labelformat=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
           },
           "operation": {
-            "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed for consistency with filter transforms.",
+            "description": "Sets the constraint operation. *=* keeps regions equal to `value` *<* and *<=* keep regions less than `value` *>* and *>=* keep regions greater than `value` *[]*, *()*, *[)*, and *(]* keep regions inside `value[0]` to `value[1]` *][*, *)(*, *](*, *)[* keep regions outside `value[0]` to value[1]` Open vs. closed intervals make no difference to constraint display, but all versions are allowed.",
             "dflt": "=",
             "editType": "calc",
             "valType": "enumerated",
@@ -109329,28 +96142,6 @@
           "valType": "any",
           "magic_underscores": "fig.update_traces(uirevision=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
         },
-        "stream": {
-          "editType": "calc",
-          "maxpoints": {
-            "description": "Sets the maximum number of points to keep on the plots from an incoming stream. If `maxpoints` is set to *50*, only the newest 50 points will be displayed on the plot.",
-            "dflt": 500,
-            "editType": "calc",
-            "max": 10000,
-            "min": 0,
-            "valType": "number",
-            "magic_underscores": "fig.update_traces(stream_maxpoints=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
-          },
-          "role": "object",
-          "token": {
-            "description": "The stream id number links a data trace on a plot with a stream. See https://chart-studio.plotly.com/settings for more details.",
-            "editType": "calc",
-            "noBlank": true,
-            "strict": true,
-            "valType": "string",
-            "magic_underscores": "fig.update_traces(stream_token=&lt;VALUE&gt;, selector=dict(type='contourcarpet'))"
-          },
-          "magic_underscores": "fig.update_traces(stream=dict(...), selector=dict(type='contourcarpet'))"
-        },
         "magic_underscores": "fig.update_traces(..., selector=dict(type='contourcarpet'))"
       },
       "categories": [

From c482cfec1d4b77427e9d73f3d862bc108dac1268 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 5 Aug 2026 10:27:38 -0600
Subject: [PATCH 16/25] Fix file name typo

---
 ...n-map.html => 2015-08-15-north-america-precipitation-map.html} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename _posts/plotly_js/maps/scatter-plot-on-maps/{2015-08-15-north-america-percipitation-map.html => 2015-08-15-north-america-precipitation-map.html} (100%)

diff --git a/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-percipitation-map.html b/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-precipitation-map.html
similarity index 100%
rename from _posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-percipitation-map.html
rename to _posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-precipitation-map.html

From 729dfbcfb83ee5496b6dcb3cb511861e113ddb09 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 5 Aug 2026 10:59:30 -0600
Subject: [PATCH 17/25] Rename file

---
 ...7-05-22-add_links.html => 2017-05-22-sankey-from-dataset.html} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename _posts/plotly_js/basic/sankey/{2017-05-22-add_links.html => 2017-05-22-sankey-from-dataset.html} (100%)

diff --git a/_posts/plotly_js/basic/sankey/2017-05-22-add_links.html b/_posts/plotly_js/basic/sankey/2017-05-22-sankey-from-dataset.html
similarity index 100%
rename from _posts/plotly_js/basic/sankey/2017-05-22-add_links.html
rename to _posts/plotly_js/basic/sankey/2017-05-22-sankey-from-dataset.html

From caa72cd4bb83dff05fe9a5b1b79d70d2e0604fc8 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 5 Aug 2026 16:26:51 -0600
Subject: [PATCH 18/25] Update existing docs for v4, add some new pages for new
 v4 features

---
 _data/make_ref_pages.py                       |   2 +-
 _data/orderings.json                          |   7 +-
 _includes/layouts/head.html                   |   6 +
 .../plotly_js/2015-04-05-plotly_js-index.html |   4 +-
 .../plotly_js/2019-07-03-is-plotly-free-js.md |   8 +-
 .../2019-04-16-basic-isosurface.html          |   2 +-
 .../2019-04-16-isosurface-slices.html         |   2 +-
 .../2019-04-16-multiple-isosurfaces-caps.html |   2 +-
 _posts/plotly_js/README.md                    |   2 +-
 .../2017-08-22-choropleth-animation.html      |   1 +
 .../basic/bubble/2015-04-09-bubblechart.html  |   2 +-
 .../2019-04-11-large-number-of-slices.html    |   2 +-
 .../2019-06-13-basic-branchvalues-total.html  |   2 +-
 .../funnel/2019-06-27-funnelarea.html         |   4 +-
 .../2019-06-27-part-of-whole-funnel.html      |   4 +-
 .../colors/2026-08-04-color-formats.html      |  36 +++++
 .../2026-08-04-colors_plotly_js_index.html    |  66 +++++++++
 .../2015-09-24-config-showSendToCloud.html    |  16 +-
 .../2019-10-24-double-click-delay.html        |   2 +-
 .../2020-01-24-remove-modebarButtons.html     |   3 +-
 .../fundamentals/latex/2015-04-09-latex.html  |   2 +-
 .../2015-04-09-latex_plotly_js_index.html     |  17 +++
 .../typescript/2026-08-04-typescript.md       | 121 +++++++++++++++
 .../bubble-maps/2015-07-11-bubble-map.html    |   3 +-
 .../2015-08-12-USA-bubble-map.html            |   2 +-
 .../2015-07-11-choropleth-north-america.html  |   2 +-
 .../2015-07-11-choropleth-world-robinson.html |   2 +-
 .../2015-08-10-countrygdp-choropleth-map.html |   2 +-
 ...2015-08-11-US-pop-by-state-choropleth.html |   2 +-
 .../2019-09-02-access-token.html              |   2 +-
 .../2019-09-02-multi-filled-area.html         |   2 +-
 .../2015-08-12-us-flight-paths-map.html       |   3 +-
 .../2015-11-07-lines-on-orthographic.html     |   2 +-
 .../maps/map-view/2026-08-04-geo-autofit.html |  41 ++++++
 .../map-view/2026-08-04-geo-zoom-limits.html  |  48 ++++++
 .../2026-08-04-map-view_plotly_js_index.html  |  57 ++++++++
 .../map-view/2026-08-04-tile-map-autofit.html |  32 ++++
 .../2026-08-04-tile-map-explicit-view.html    |  37 +++++
 ...9-migrate-to-maplibre_plotly_js_index.html |  28 +++-
 .../2019-07-03-country-names-example.html     |   7 +
 .../2019-07-03-country-names-warning.html     |  10 --
 .../2019-07-03-iso3-table.html                | 138 +++++++++---------
 .../2015-08-12-US-airport-map.html            |   2 +-
 ...08-15-north-america-precipitation-map.html |  25 ++--
 .../2017-08-01-scattermapbox_lines.html       |   2 +-
 .../scattermapbox/2019-09-02-symbols.html     |   6 +-
 .../quiver/2026-08-04-basic-quiver.html       |  27 ++++
 .../quiver/2026-08-04-quiver-anchor-size.html |  47 ++++++
 .../quiver/2026-08-04-quiver-color.html       |  57 ++++++++
 .../quiver/2026-08-04-quiver-style.html       |  66 +++++++++
 .../2026-08-04-quiver_plotly_js_index.html    |  37 +++++
 .../2016-02-15-continuous-variable.html       |   4 +-
 .../error-bar/2015-04-09-error-bar-style.html |   2 +-
 .../2017-01-20-mixed-subplots.html            |   3 +-
 .../2015-04-09-multiple-axes-double.html      |   4 +
 .../2026-08-04-overlaying-axis-tickmode.html  |  53 +++++++
 56 files changed, 925 insertions(+), 143 deletions(-)
 create mode 100644 _posts/plotly_js/fundamentals/colors/2026-08-04-color-formats.html
 create mode 100644 _posts/plotly_js/fundamentals/colors/2026-08-04-colors_plotly_js_index.html
 create mode 100644 _posts/plotly_js/guides/typescript/2026-08-04-typescript.md
 create mode 100644 _posts/plotly_js/maps/map-view/2026-08-04-geo-autofit.html
 create mode 100644 _posts/plotly_js/maps/map-view/2026-08-04-geo-zoom-limits.html
 create mode 100644 _posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html
 create mode 100644 _posts/plotly_js/maps/map-view/2026-08-04-tile-map-autofit.html
 create mode 100644 _posts/plotly_js/maps/map-view/2026-08-04-tile-map-explicit-view.html
 delete mode 100644 _posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-warning.html
 create mode 100644 _posts/plotly_js/scientific/quiver/2026-08-04-basic-quiver.html
 create mode 100644 _posts/plotly_js/scientific/quiver/2026-08-04-quiver-anchor-size.html
 create mode 100644 _posts/plotly_js/scientific/quiver/2026-08-04-quiver-color.html
 create mode 100644 _posts/plotly_js/scientific/quiver/2026-08-04-quiver-style.html
 create mode 100644 _posts/plotly_js/scientific/quiver/2026-08-04-quiver_plotly_js_index.html
 create mode 100644 _posts/plotly_js/subplot/multiple-axes/2026-08-04-overlaying-axis-tickmode.html

diff --git a/_data/make_ref_pages.py b/_data/make_ref_pages.py
index ee5e118ab..a76c18fb5 100644
--- a/_data/make_ref_pages.py
+++ b/_data/make_ref_pages.py
@@ -9,7 +9,7 @@
     lang = "csharp" if lang == "c#" else lang
     langcode = "plotly_js" if lang == "javascript" else lang
     for attr in [
-        "xaxis", "yaxis", "coloraxis", "scene", "polar", "ternary", "smith", "geo", "mapbox",
+        "xaxis", "yaxis", "coloraxis", "scene", "polar", "ternary", "smith", "geo", "map",
         "sliders", "updatemenus", "annotations", "shapes", "images","selections", "global"
     ]:
         fullattr = "layout" + ("." + attr if attr != "global" else "")
diff --git a/_data/orderings.json b/_data/orderings.json
index bbc9c956a..d8312694b 100644
--- a/_data/orderings.json
+++ b/_data/orderings.json
@@ -50,7 +50,6 @@
          "scene",
          "geo",
          "map",
-         "mapbox",
          "polar",
          "smith",
 
@@ -63,8 +62,6 @@
          "sliders",
          "selections",
 
-         "hidesources",
-
          "_deprecated",
          "radialaxis",
          "angularaxis",
@@ -75,7 +72,7 @@
     "traces": [
       "scatter", "scattergl",
         "bar", "pie", "heatmap", "heatmapgl","image",
-        "contour", "table",
+        "contour", "quiver", "table",
 
         "box", "violin", "histogram", "histogram2d", "histogram2dcontour",
 
@@ -83,7 +80,7 @@
 
         "scatter3d", "surface", "mesh3d", "cone", "streamtube", "volume", "isosurface",
 
-        "scattergeo", "choropleth", "scattermap", "scattermapbox", "choroplethmap", "choroplethmapbox", "densitymap", "densitymapbox",
+        "scattergeo", "choropleth", "scattermap", "choroplethmap", "densitymap",
 
         "scatterpolar", "scatterpolargl", "barpolar", "scatterternary", "scattersmith", "sunburst", "treemap", "icicle",
 
diff --git a/_includes/layouts/head.html b/_includes/layouts/head.html
index c13b2da6a..a1f6c3673 100644
--- a/_includes/layouts/head.html
+++ b/_includes/layouts/head.html
@@ -35,7 +35,13 @@
   {% endif %}
 
   <!-- Mathjax -->
+  {% if page.language == "r" or page.language == "ggplot2" %}
+  <!-- MathJax v2, kept for the hardcoded plotly.js 1.58.4 bundle loaded on R/ggplot2 pages below -->
   <script type="text/javascript" src="//cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML"></script>
+  {% else %}
+  <!-- MathJax v3 (tex-svg). Plotly.js v4 removed MathJax v2 support; v3 works with v2.x and v3.x bundles too. -->
+  <script type="text/javascript" src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js"></script>
+  {% endif %}
 
   {% if page.language == "plotly_js" %}
   <script src="//cdnjs.cloudflare.com/ajax/libs/d3/3.5.17/d3.min.js"></script>
diff --git a/_posts/plotly_js/2015-04-05-plotly_js-index.html b/_posts/plotly_js/2015-04-05-plotly_js-index.html
index 1e7a81041..de73c653f 100755
--- a/_posts/plotly_js/2015-04-05-plotly_js-index.html
+++ b/_posts/plotly_js/2015-04-05-plotly_js-index.html
@@ -77,7 +77,7 @@ <h1>Plotly JavaScript Open Source Graphing Library</h1>
                       x: 0, y: 0, xref: 'paper', yref: 'paper'
                     }]
                   }
-                  Plotly.newPlot(document.getElementById('contour-plot'), [trace], layout, {showLink: false});
+                  Plotly.newPlot(document.getElementById('contour-plot'), [trace], layout);
                 });</code></pre>
 
 
@@ -127,7 +127,7 @@ <h1>Plotly JavaScript Open Source Graphing Library</h1>
                       }
                     };
 
-                    Plotly.newPlot(document.getElementById('wind-speed'), [trace], layout, {showLink: false});
+                    Plotly.newPlot(document.getElementById('wind-speed'), [trace], layout);
                 });</code></pre>
 
 
diff --git a/_posts/plotly_js/2019-07-03-is-plotly-free-js.md b/_posts/plotly_js/2019-07-03-is-plotly-free-js.md
index 654c7aa2a..c6f97b378 100644
--- a/_posts/plotly_js/2019-07-03-is-plotly-free-js.md
+++ b/_posts/plotly_js/2019-07-03-is-plotly-free-js.md
@@ -16,13 +16,15 @@ language: plotly_js
 #### Can I use Plotly.js without signing up to any service?
 
 &nbsp;  &nbsp; **Yes.** &nbsp; You can use Plotly.js to make, view, and distribute charts and maps without registering for any service,
-obtaining any token, or creating any account. The one exception is that to view tile maps
-which use tiles from the Mapbox service (which is optional, as [you can use other tile servers](/javascript/mapbox-layers)), you will need to have a Mapbox token.
+obtaining any token, or creating any account. The built-in tile map styles use open tile providers and need no token. Some
+third-party tile providers you can [point Plotly.js at](/javascript/tile-map-layers) do require an account with that
+provider — Stamen tiles, for instance, are served by Stadia Maps and need a Stadia API key. Sharing a chart with
+[Plotly Cloud](https://cloud.plotly.com) from the modebar requires a Plotly Cloud account, but nothing else does.
 
 #### Can I use Plotly.js offline, without being connected to the internet?
 
 &nbsp;  &nbsp; **Yes.** &nbsp; You can use Plotly.js to make, view, and distribute  graphics totally offline. The one exception is that to view tile maps
-which use tiles from a cloud-hosted service, such as Open Street Maps or Mapbox, you will need a connection to that service. You can view tile maps totally offline if  you run your own local tile server and [use its tiles](/javascript/mapbox-layers).
+which use tiles from a cloud-hosted service, such as OpenStreetMap, you will need a connection to that service. You can view tile maps totally offline if you run your own local tile server and [use its tiles](/javascript/tile-map-layers).
 
 #### Is Dash free?
 
diff --git a/_posts/plotly_js/3d/3d-isosurface/2019-04-16-basic-isosurface.html b/_posts/plotly_js/3d/3d-isosurface/2019-04-16-basic-isosurface.html
index 7e7e3da8b..620b3b24c 100644
--- a/_posts/plotly_js/3d/3d-isosurface/2019-04-16-basic-isosurface.html
+++ b/_posts/plotly_js/3d/3d-isosurface/2019-04-16-basic-isosurface.html
@@ -33,4 +33,4 @@
     }
 };
 
-Plotly.newPlot('myDiv', data, layout, {showSendToCloud: true});
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/3d/3d-isosurface/2019-04-16-isosurface-slices.html b/_posts/plotly_js/3d/3d-isosurface/2019-04-16-isosurface-slices.html
index 35cd65078..1fb5a4780 100644
--- a/_posts/plotly_js/3d/3d-isosurface/2019-04-16-isosurface-slices.html
+++ b/_posts/plotly_js/3d/3d-isosurface/2019-04-16-isosurface-slices.html
@@ -46,5 +46,5 @@
     }
 };
 
-Plotly.newPlot('myDiv', data, layout, {showSendToCloud: true});
+Plotly.newPlot('myDiv', data, layout);
 });
diff --git a/_posts/plotly_js/3d/3d-isosurface/2019-04-16-multiple-isosurfaces-caps.html b/_posts/plotly_js/3d/3d-isosurface/2019-04-16-multiple-isosurfaces-caps.html
index cbe303429..2d59af0f4 100644
--- a/_posts/plotly_js/3d/3d-isosurface/2019-04-16-multiple-isosurfaces-caps.html
+++ b/_posts/plotly_js/3d/3d-isosurface/2019-04-16-multiple-isosurfaces-caps.html
@@ -43,6 +43,6 @@
     }
 };
 
-Plotly.newPlot('myDiv', data, layout, {showSendToCloud: true});
+Plotly.newPlot('myDiv', data, layout);
 });
 
diff --git a/_posts/plotly_js/README.md b/_posts/plotly_js/README.md
index 82a5b5a00..18ba35509 100644
--- a/_posts/plotly_js/README.md
+++ b/_posts/plotly_js/README.md
@@ -122,7 +122,7 @@ Plotly.newPlot('myDiv', data);
   - use "real" data to make the examples realistic and useful for users. 
     - avoid using random or dummy data as much as humanly possible! Should only be a last resort. 
   - upload data files to https://github.com/plotly/datasets as importing data rather than pasting a large chunk of data in the tutorial creates a cleaner example. 
-   - use `var config = {mapboxAccessToken: "your access token"};` if your chart requires Mapbox authentication. `"your access token` will replaced by Plotly's private token at build time. In development mode, you will need to create a `_data/mapboxtoken.yml` file and paste Plotly's non-URL restricted Mapbox key into it. This is available in 1Password.
+   - map examples must not require an API key. The `map` traces (`scattermap`, `choroplethmap`, `densitymap`) use open tile providers, and the `mapboxAccessToken` config option was removed in Plotly.js v4. Keep the example's `layout.map.style` set to a built-in style name or to a keyless style URL, so the chart renders for everyone reading the page. If you want to document a provider that does need a key, put that URL in `markdown_content` as a code snippet for the reader to copy and add their own key to — don't put it in the example itself, where a placeholder key means the rendered chart has no tiles and a real key would be committed to a public repo.
        
 ## Make a Pull Request
   - Ready for your changes to be reviewed? Make a pull request!
diff --git a/_posts/plotly_js/animations/map-animations/2017-08-22-choropleth-animation.html b/_posts/plotly_js/animations/map-animations/2017-08-22-choropleth-animation.html
index 552dff20a..2bad23280 100644
--- a/_posts/plotly_js/animations/map-animations/2017-08-22-choropleth-animation.html
+++ b/_posts/plotly_js/animations/map-animations/2017-08-22-choropleth-animation.html
@@ -52,6 +52,7 @@
     },
     geo:{
        scope: 'world',
+       fitbounds: false,
        countrycolor: 'rgb(255, 255, 255)',
        showland: true,
        landcolor: 'rgb(217, 217, 217)',
diff --git a/_posts/plotly_js/basic/bubble/2015-04-09-bubblechart.html b/_posts/plotly_js/basic/bubble/2015-04-09-bubblechart.html
index 9cbb99505..ec70aa21b 100755
--- a/_posts/plotly_js/basic/bubble/2015-04-09-bubblechart.html
+++ b/_posts/plotly_js/basic/bubble/2015-04-09-bubblechart.html
@@ -12,7 +12,7 @@
   y: [10, 11, 12, 13],
   mode: 'markers',
   marker: {
-    color: ['hsl(0,100,40)', 'hsl(33,100,40)', 'hsl(66,100,40)', 'hsl(99,100,40)'],
+    color: ['hsl(0,100%,40%)', 'hsl(33,100%,40%)', 'hsl(66,100%,40%)', 'hsl(99,100%,40%)'],
     size: [12, 22, 32, 42],
     opacity: [0.6, 0.7, 0.8, 0.9]
   },
diff --git a/_posts/plotly_js/basic/sunburst/2019-04-11-large-number-of-slices.html b/_posts/plotly_js/basic/sunburst/2019-04-11-large-number-of-slices.html
index 4f547131c..4119bdf0f 100644
--- a/_posts/plotly_js/basic/sunburst/2019-04-11-large-number-of-slices.html
+++ b/_posts/plotly_js/basic/sunburst/2019-04-11-large-number-of-slices.html
@@ -31,5 +31,5 @@
 };
 
 
-Plotly.newPlot('myDiv', data, layout, {showSendToCloud: true});
+Plotly.newPlot('myDiv', data, layout);
 })
diff --git a/_posts/plotly_js/basic/sunburst/2019-06-13-basic-branchvalues-total.html b/_posts/plotly_js/basic/sunburst/2019-06-13-basic-branchvalues-total.html
index 79dd390f4..4089d57d0 100755
--- a/_posts/plotly_js/basic/sunburst/2019-06-13-basic-branchvalues-total.html
+++ b/_posts/plotly_js/basic/sunburst/2019-06-13-basic-branchvalues-total.html
@@ -29,6 +29,6 @@
 };
 
 
-Plotly.newPlot('myDiv', data, layout, {showSendToCloud: true})
+Plotly.newPlot('myDiv', data, layout)
 
 myPlot = document.getElementById("myDiv");
diff --git a/_posts/plotly_js/financial/funnel/2019-06-27-funnelarea.html b/_posts/plotly_js/financial/funnel/2019-06-27-funnelarea.html
index fd5d4c059..ff245bd4c 100755
--- a/_posts/plotly_js/financial/funnel/2019-06-27-funnelarea.html
+++ b/_posts/plotly_js/financial/funnel/2019-06-27-funnelarea.html
@@ -8,8 +8,8 @@
 ---
 var gd = document.getElementById('myDiv');
 var data = [{type: 'funnelarea', values: [5, 4, 3, 2, 1], text: ["The 1st", "The 2nd", "The 3rd", "The 4th", "The 5th"],
-      marker: {colors: ["59D4E8", "DDB6C6", "A696C8", "67EACA", "94D2E6"],
-                line: {color: ["3E4E88", "606470", "3E4E88", "606470", "3E4E88"], width: [2, 1, 5, 0, 3]}},
+      marker: {colors: ["#59D4E8", "#DDB6C6", "#A696C8", "#67EACA", "#94D2E6"],
+                line: {color: ["#3E4E88", "#606470", "#3E4E88", "#606470", "#3E4E88"], width: [2, 1, 5, 0, 3]}},
       textfont: {family: "Old Standard TT", size: 13, color: "black"}, opacity: 0.65}];
 
 var layout = {margin: {l: 200 , r: 200}, funnelmode: "stack", showlegend: 'True'}
diff --git a/_posts/plotly_js/financial/funnel/2019-06-27-part-of-whole-funnel.html b/_posts/plotly_js/financial/funnel/2019-06-27-part-of-whole-funnel.html
index eab16fd2c..6a3769339 100755
--- a/_posts/plotly_js/financial/funnel/2019-06-27-part-of-whole-funnel.html
+++ b/_posts/plotly_js/financial/funnel/2019-06-27-part-of-whole-funnel.html
@@ -11,8 +11,8 @@
 var data = [{type: 'funnel',
              y: ["Sales person A", "Sales person B", "Sales person C", "Sales person D", "Sales person E"],
              x: [1200, 909.4, 600.6, 300, 80], textposition: "inside", textinfo: "value+percent initial",
-             hoverinfo: 'percent total+x', opacity: 0.65, marker: {color: ["59D4E8", "DDB6C6", "A696C8", "67EACA", "94D2E6"],
-             line: {"width": [4, 2, 2, 3, 1, 1], color: ["3E4E88", "606470", "3E4E88", "606470", "3E4E88"]}},
+             hoverinfo: 'percent total+x', opacity: 0.65, marker: {color: ["#59D4E8", "#DDB6C6", "#A696C8", "#67EACA", "#94D2E6"],
+             line: {"width": [4, 2, 2, 3, 1, 1], color: ["#3E4E88", "#606470", "#3E4E88", "#606470", "#3E4E88"]}},
              connector: {line: {color: "royalblue", dash: "dot", width: 3}}}];
 
 var layout = {margin: {l: 100}, width: 600, height: 500}
diff --git a/_posts/plotly_js/fundamentals/colors/2026-08-04-color-formats.html b/_posts/plotly_js/fundamentals/colors/2026-08-04-color-formats.html
new file mode 100644
index 000000000..b29101de9
--- /dev/null
+++ b/_posts/plotly_js/fundamentals/colors/2026-08-04-color-formats.html
@@ -0,0 +1,36 @@
+---
+name: Color Format Examples
+language: plotly_js
+suite: colors
+order: 1
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  One bar per accepted color format, each written a different way but all resolving to a valid color.
+---
+var data = [{
+  type: 'bar',
+  x: ['named', 'hex', 'hex + alpha', 'rgb', 'rgb / alpha', 'hsl', 'hwb'],
+  y: [1, 1, 1, 1, 1, 1, 1],
+  marker: {
+    color: [
+      'crimson',
+      '#2ca02c',
+      '#1f77b4aa',
+      'rgb(255 127 14)',
+      'rgba(148, 103, 189, 0.45)',
+      'hsl(180, 70%, 40%)',
+      'hwb(320 10% 20%)'
+    ],
+    line: {color: '#444', width: 1}
+  }
+}];
+
+var layout = {
+  title: {text: 'Accepted Color String Formats'},
+  yaxis: {visible: false},
+  width: 700,
+  height: 400
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/fundamentals/colors/2026-08-04-colors_plotly_js_index.html b/_posts/plotly_js/fundamentals/colors/2026-08-04-colors_plotly_js_index.html
new file mode 100644
index 000000000..9d3767ad2
--- /dev/null
+++ b/_posts/plotly_js/fundamentals/colors/2026-08-04-colors_plotly_js_index.html
@@ -0,0 +1,66 @@
+---
+description: How to specify colors in JavaScript. The CSS color string formats Plotly.js accepts for every color attribute.
+display_as: file_settings
+language: plotly_js
+layout: base
+name: Specifying Colors
+order: 27
+page_type: example_index
+permalink: javascript/colors/
+thumbnail: thumbnail/colorway.jpg
+---
+
+<p>Every color attribute in Plotly.js — <code>marker.color</code>, <code>line.color</code>,
+<code>fillcolor</code>, <code>paper_bgcolor</code>, and the rest — accepts a CSS color string. Plotly.js v4 parses
+colors according to the <a href="https://www.w3.org/TR/css-color-4/" target="_blank">CSS Color 4</a> specification.</p>
+
+<h4>Accepted formats</h4>
+
+<table>
+  <tr><th>Format</th><th>Notes</th><th>Examples</th></tr>
+  <tr>
+    <td>Named colors</td>
+    <td>Any CSS color keyword</td>
+    <td><code>'red'</code>, <code>'cornflowerblue'</code>, <code>'transparent'</code></td>
+  </tr>
+  <tr>
+    <td>Hex</td>
+    <td>3-, 4-, 6-, or 8-digit, always with a leading <code>#</code></td>
+    <td><code>'#f00'</code>, <code>'#f00a'</code>, <code>'#ff0000'</code>, <code>'#ff0000aa'</code></td>
+  </tr>
+  <tr>
+    <td><code>rgb()</code>, <code>rgba()</code></td>
+    <td>Comma- or space-separated, with optional slash alpha</td>
+    <td><code>'rgb(255, 0, 0)'</code>, <code>'rgb(255 0 0)'</code>, <code>'rgba(255, 0, 0, 0.5)'</code>, <code>'rgba(255 0 0 / 0.5)'</code></td>
+  </tr>
+  <tr>
+    <td><code>hsl()</code>, <code>hsla()</code></td>
+    <td>Percent units required on saturation and lightness</td>
+    <td><code>'hsl(0, 100%, 50%)'</code>, <code>'hsl(0 100% 50% / 0.5)'</code></td>
+  </tr>
+  <tr>
+    <td><code>hwb()</code></td>
+    <td>Hue-whiteness-blackness, space-separated</td>
+    <td><code>'hwb(0 0% 0%)'</code></td>
+  </tr>
+  <tr>
+    <td>Hue</td>
+    <td>Given in degrees, with or without the <code>deg</code> unit</td>
+    <td><code>'hsl(0deg 100% 50%)'</code>, <code>'hsl(0 100% 50%)'</code></td>
+  </tr>
+</table>
+
+<p>These are all parsed in JavaScript and normalized to <code>rgb()</code> / <code>rgba()</code> before being written
+to the DOM in the browser.</p>
+
+<p>A color string that Plotly.js cannot parse falls back to the attribute's default, so the figure renders in the wrong
+color rather than failing loudly. If you are upgrading from an earlier version, see
+<a href="/javascript/guides/migrating-to-v4/">Migrating to Plotly.js v4</a> for the formats that are no longer
+accepted.</p>
+
+<p>These rules apply to color <i>strings</i> only. Numeric arrays used for color mapping, such as
+<code>marker.color: [1, 2, 3, 4]</code> paired with a <a href="/javascript/colorscales/">colorscale</a>, are
+unaffected.</p>
+
+{% assign examples = site.posts | where:"language","plotly_js" | where:"suite","colors" | sort: "order" %}
+{% include posts/auto_examples.html examples=examples %}
diff --git a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html b/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html
index 0a906c626..3373b7748 100644
--- a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html
+++ b/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html
@@ -1,10 +1,16 @@
 ---
-name: Display Edit in Chart Studio Modebar Button
+name: Share with Plotly Cloud
 language: plotly_js
 suite: configuration
-order: 7.1
+order: 6
 sitemap: false
 arrangement: horizontal
+markdown_content: |
+  The `sendChartToCloud` modebar button sends the chart to [Plotly Cloud](https://cloud.plotly.com) and opens it in a
+  new tab, where you can copy a sharing link and set the chart's visibility. A Plotly Cloud account is required.
+
+  The button is shown by default. Set `showSendToCloud: false` to hide it, or set `plotlyServerURL` to send charts to
+  a self-hosted or alternate server instead of `cloud.plotly.com`.
 ---
 var data = [{
   values: [19, 26, 55],
@@ -14,13 +20,13 @@
 
 var layout = {
   title: {
-      text: 'Show Edit in Chart Studio Modebar Button'
+      text: 'Share with Plotly Cloud'
   }
 };
 
 var config = {
-  showEditInChartStudio: true,
-  plotlyServerURL: "https://chart-studio.plotly.com"
+  showSendToCloud: true,
+  plotlyServerURL: "https://cloud.plotly.com"
 };
 
 Plotly.newPlot('myDiv', data, layout, config);
diff --git a/_posts/plotly_js/fundamentals/config-options/2019-10-24-double-click-delay.html b/_posts/plotly_js/fundamentals/config-options/2019-10-24-double-click-delay.html
index 29c457dae..ac3aae795 100755
--- a/_posts/plotly_js/fundamentals/config-options/2019-10-24-double-click-delay.html
+++ b/_posts/plotly_js/fundamentals/config-options/2019-10-24-double-click-delay.html
@@ -7,7 +7,7 @@
 arrangement: horizontal
 markdown_content: |
      Sets the maximum delay between two consecutive clicks to be interpreted as a double-click in ms. This is the time interval between first mousedown, and' second mouseup. The default timing is 300 ms (less than half a second).
-     This setting propagates to all on-subplot double clicks, (except for geo, map, and mapbox).
+     This setting propagates to all on-subplot double clicks, (except for geo and map).
 ---
 var data = [{
   type: "bar",
diff --git a/_posts/plotly_js/fundamentals/config-options/2020-01-24-remove-modebarButtons.html b/_posts/plotly_js/fundamentals/config-options/2020-01-24-remove-modebarButtons.html
index 75190eedb..f9704eae5 100644
--- a/_posts/plotly_js/fundamentals/config-options/2020-01-24-remove-modebarButtons.html
+++ b/_posts/plotly_js/fundamentals/config-options/2020-01-24-remove-modebarButtons.html
@@ -12,7 +12,8 @@
          <li> -'3D', `zoom3d`, `pan3d`, `orbitRotation`, `tableRotation`, `handleDrag3d`, `resetCameraDefault3d`, `resetCameraLastSave3d`, `hoverClosest3d` </li>
          <li> -'Cartesian', `hoverClosestCartesian`, `hoverCompareCartesian` </li>
          <li> -'Geo', `zoomInGeo`, `zoomOutGeo`, `resetGeo`, `hoverClosestGeo` </li>
-         <li> -'Other', `hoverClosestGl2d`, `hoverClosestPie`, `toggleHover`, `resetViews`, `toImage`, `sendDataToCloud`, `toggleSpikelines`, `resetViewMapbox` </li>
+         <li> -'Map', `zoomInMap`, `zoomOutMap`, `resetViewMap` </li>
+         <li> -'Other', `hoverClosestGl2d`, `hoverClosestPie`, `toggleHover`, `resetViews`, `toImage`, `sendChartToCloud`, `toggleSpikelines` </li>
      </ul>
 ---
 var data = [{
diff --git a/_posts/plotly_js/fundamentals/latex/2015-04-09-latex.html b/_posts/plotly_js/fundamentals/latex/2015-04-09-latex.html
index 569c1754e..fc41e35cf 100644
--- a/_posts/plotly_js/fundamentals/latex/2015-04-09-latex.html
+++ b/_posts/plotly_js/fundamentals/latex/2015-04-09-latex.html
@@ -6,7 +6,7 @@
 order: 0
 sitemap: false
 ---
-// remember to load MathJax.js?config=TeX-MML-AM_CHTML
+// remember to load MathJax v3 or v4 (tex-svg.js) - see https://plotly.com/javascript/LaTeX/
 var trace1 = {
   x: [1, 2, 3, 4],
   y: [1, 4, 9, 16],
diff --git a/_posts/plotly_js/fundamentals/latex/2015-04-09-latex_plotly_js_index.html b/_posts/plotly_js/fundamentals/latex/2015-04-09-latex_plotly_js_index.html
index d4f33c035..034837272 100755
--- a/_posts/plotly_js/fundamentals/latex/2015-04-09-latex_plotly_js_index.html
+++ b/_posts/plotly_js/fundamentals/latex/2015-04-09-latex_plotly_js_index.html
@@ -11,5 +11,22 @@
 thumbnail: thumbnail/venn.jpg
 ---
 
+<p>Plotly.js renders LaTeX in titles, axis labels, annotations, and legend entries when
+<a href="https://www.mathjax.org/" target="_blank">MathJax</a> is loaded on the page. Wrap the expression in
+<code>$</code> delimiters, as in the example below.</p>
+
+<p>Plotly.js v4 supports MathJax v3 and v4, and uses the <code>tex-svg</code> component. Load one of the following
+before plotly.js:</p>
+
+<pre><code class="hljs html">&lt;!-- MathJax v3 --&gt;
+&lt;script src="https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js"&gt;&lt;/script&gt;
+&lt;!-- or MathJax v4 --&gt;
+&lt;script src="https://cdn.jsdelivr.net/npm/mathjax@4/tex-svg.js"&gt;&lt;/script&gt;</code></pre>
+
+<p>MathJax v2 is no longer supported. If your page loads
+<code>MathJax.js?config=TeX-MML-AM_CHTML</code>, replace it with one of the tags above — the
+<code>?config=</code> query string is not used from MathJax v3 onward, since the component is
+selected by the file you load.</p>
+
 {% assign examples = site.posts | where:"language","plotly_js" | where:"suite","latex" | sort: "order" %}
 {% include posts/auto_examples.html examples=examples %}
\ No newline at end of file
diff --git a/_posts/plotly_js/guides/typescript/2026-08-04-typescript.md b/_posts/plotly_js/guides/typescript/2026-08-04-typescript.md
new file mode 100644
index 000000000..937926d0b
--- /dev/null
+++ b/_posts/plotly_js/guides/typescript/2026-08-04-typescript.md
@@ -0,0 +1,121 @@
+---
+description: How to use Plotly.js with TypeScript, including the types it ships and how to type figures, layouts, configs, and events.
+display_as: guide
+language: plotly_js
+layout: base
+name: Using Plotly.js with TypeScript
+order: 4
+page_type: u-guide
+permalink: javascript/guides/typescript/
+sitemap: false
+thumbnail: thumbnail/mixed.jpg
+---
+# Using Plotly.js with TypeScript
+
+Since v4, Plotly.js ships its own TypeScript type definitions. `package.json` points
+`"types"` at `lib/index.d.ts`, so they are picked up automatically — there is no
+separate `@types/*` package to install.
+
+## Importing
+
+The package provides a default namespace, named exports, and a global `Plotly`
+namespace, so all of these work:
+
+```ts
+import Plotly from 'plotly.js';
+// or
+import * as Plotly from 'plotly.js';
+// or
+import { newPlot } from 'plotly.js';
+import type { Layout, Data, TraceType } from 'plotly.js';
+```
+
+A minimal typed figure:
+
+```ts
+import { newPlot } from 'plotly.js';
+import type { Data, Layout } from 'plotly.js';
+
+const data: Data[] = [{ type: 'scatter', x: [1, 2, 3], y: [4, 5, 6] }];
+const layout: Partial<Layout> = { title: { text: 'Demo' } };
+
+await newPlot(div, data, layout);
+```
+
+## Typing trace data
+
+`Data` is the union of every trace's data object, and it discriminates on `type`.
+Annotating a figure as `Data[]` therefore gets each entry checked against the right
+trace shape:
+
+```ts
+const data: Data[] = [
+    { type: 'bar', x: ['a', 'b'], y: [1, 2] },     // checked as BarData
+    { type: 'scatter', x: [1, 2], mode: 'lines' }, // checked as ScatterData
+];
+```
+
+Per-trace interfaces (`ScatterData`, `BarData`, `HeatmapData`, `ChoroplethData`, …)
+are exported too. Reach for them when a value is guaranteed to be one trace type —
+for example a helper that builds a `BarData` to push into a `Data[]` — and prefer the
+`Data` union everywhere else.
+
+## Typing layout and config
+
+`Layout` describes the layout object you pass in, so use `Partial<Layout>`: nearly
+every field is optional, and the full interface would require all of them.
+`Config` types the config argument.
+
+```ts
+import type { Config, Layout } from 'plotly.js';
+
+const layout: Partial<Layout> = {
+    title: { text: 'Quarterly revenue' },
+    yaxis: { tickformat: '$,.0f' },
+};
+
+const config: Partial<Config> = { responsive: true, showSendToCloud: false };
+```
+
+Note that `Layout` and `Data` are *input* shapes. The post-coerce internal shapes
+that Plotly computes from them (often called "FullLayout" and "FullData") are
+deliberately not exported.
+
+## Typing events
+
+Event payloads have their own interfaces, and `PlotlyHTMLElement` types the graph
+div that `newPlot` resolves to:
+
+```ts
+import { newPlot } from 'plotly.js';
+import type { PlotMouseEvent, PlotRelayoutEvent } from 'plotly.js';
+
+const gd = await newPlot(div, data, layout);
+
+gd.on('plotly_click', (event: PlotMouseEvent) => {
+    console.log(event.points[0].x, event.points[0].y);
+});
+
+gd.on('plotly_relayout', (event: PlotRelayoutEvent) => {
+    console.log(event['xaxis.range[0]']);
+});
+```
+
+`PlotlyEventName` is the union of names accepted by `on()`, `once()`, and
+`removeListener()`.
+
+## What else is exported
+
+| Category | Exports |
+|---|---|
+| Layout components | `LayoutAxis`, `Legend`, `Annotation`, `Shape`, `Slider`, `UpdateMenu`, `Scene`, and the other component interfaces |
+| Config and image export | `Config`, `ToImgopts`, `DownloadImgopts`, `ToImageButtonOptions`, `ModeBarDefaultButtons`, `ModeBarButton`, `Icon` |
+| Enums | String-literal unions such as `TraceType`, `AxisType`, `Calendar`, `Dash`, `PatternShape`, `XRef`, `YRef`, `MarkerSymbol`, `HoverInfo` — use these instead of `string` to get narrowing on attribute values |
+| Shared sub-interfaces | `Font`, `ColorBar`, `HoverLabel`, `Pattern`, `Domain`, `LegendGroupTitle`, `TickFormatStops` |
+| Events | `PlotMouseEvent`, `PlotHoverEvent`, `PlotSelectionEvent`, `PlotRelayoutEvent`, `PlotRestyleEvent`, `LegendClickEvent`, `SliderChangeEvent`, `PlotlyEventName` |
+| Animation and frames | `AnimationOpts`, `Frame`, `Transition`, `TransitionEasing` |
+| Templates | `Template`, `TemplateFigure`, `ValidateTemplateResult` |
+| DOM and values | `PlotlyHTMLElement`, `Datum`, `TypedArray`, `Color`, `ColorScale` |
+
+`PlotType` is an alias for `TraceType`, so existing imports keep compiling. New code
+should prefer `TraceType`.
diff --git a/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble-map.html b/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble-map.html
index 42144cbe1..7edc2db44 100755
--- a/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble-map.html
+++ b/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble-map.html
@@ -32,7 +32,8 @@
 var layout = {
     'geo': {
         'scope': 'europe',
-        'resolution': 50
+        'resolution': 50,
+        'fitbounds': false
     }
 };
 
diff --git a/_posts/plotly_js/maps/bubble-maps/2015-08-12-USA-bubble-map.html b/_posts/plotly_js/maps/bubble-maps/2015-08-12-USA-bubble-map.html
index 3ee9eae66..38c791f0d 100644
--- a/_posts/plotly_js/maps/bubble-maps/2015-08-12-USA-bubble-map.html
+++ b/_posts/plotly_js/maps/bubble-maps/2015-08-12-USA-bubble-map.html
@@ -61,6 +61,6 @@
         },
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 
 });
diff --git a/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-north-america.html b/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-north-america.html
index 2568e1e4d..520ac94ed 100755
--- a/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-north-america.html
+++ b/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-north-america.html
@@ -44,5 +44,5 @@
         }
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 });
diff --git a/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-world-robinson.html b/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-world-robinson.html
index 07b25c214..13d889851 100755
--- a/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-world-robinson.html
+++ b/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth-world-robinson.html
@@ -28,5 +28,5 @@
         }
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 });
diff --git a/_posts/plotly_js/maps/choropleth-maps/2015-08-10-countrygdp-choropleth-map.html b/_posts/plotly_js/maps/choropleth-maps/2015-08-10-countrygdp-choropleth-map.html
index 4ab8a485f..e1faa7781 100644
--- a/_posts/plotly_js/maps/choropleth-maps/2015-08-10-countrygdp-choropleth-map.html
+++ b/_posts/plotly_js/maps/choropleth-maps/2015-08-10-countrygdp-choropleth-map.html
@@ -48,5 +48,5 @@
         }
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 });
diff --git a/_posts/plotly_js/maps/choropleth-maps/2015-08-11-US-pop-by-state-choropleth.html b/_posts/plotly_js/maps/choropleth-maps/2015-08-11-US-pop-by-state-choropleth.html
index 798840157..7d8c28531 100644
--- a/_posts/plotly_js/maps/choropleth-maps/2015-08-11-US-pop-by-state-choropleth.html
+++ b/_posts/plotly_js/maps/choropleth-maps/2015-08-11-US-pop-by-state-choropleth.html
@@ -34,5 +34,5 @@
         }
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 });
diff --git a/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-access-token.html b/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-access-token.html
index dd3da713d..e60957f3d 100644
--- a/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-access-token.html
+++ b/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-access-token.html
@@ -27,7 +27,7 @@ <h6> Filled `Scattermap` Trace </h6>
 
 var layout = {
 	map: {
-		style: "stamen-terrain",
+		style: "open-street-map",
 		center: { lon: -73, lat: 46 },
 		zoom: 5
 	},
diff --git a/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-multi-filled-area.html b/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-multi-filled-area.html
index 600fa264e..374f41ea0 100644
--- a/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-multi-filled-area.html
+++ b/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-multi-filled-area.html
@@ -18,7 +18,7 @@
 		}]
 
 var layout = {
-	map: {style: "stamen-terrain", center: {lon: 40, lat: 20}, 'zoom': 1.5},
+	map: {style: "open-street-map", center: {lon: 40, lat: 20}, 'zoom': 1.5},
 	showlegend: false,
 	width:700, height: 700}
 
diff --git a/_posts/plotly_js/maps/lines-on-maps/2015-08-12-us-flight-paths-map.html b/_posts/plotly_js/maps/lines-on-maps/2015-08-12-us-flight-paths-map.html
index 153c32d5c..544ef4e10 100644
--- a/_posts/plotly_js/maps/lines-on-maps/2015-08-12-us-flight-paths-map.html
+++ b/_posts/plotly_js/maps/lines-on-maps/2015-08-12-us-flight-paths-map.html
@@ -45,6 +45,7 @@
         showlegend: false,
         geo:{
             scope: 'north america',
+            fitbounds: false,
             projection: {
                 type: 'azimuthal equal area'
             },
@@ -54,6 +55,6 @@
         }
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 
 });
diff --git a/_posts/plotly_js/maps/lines-on-maps/2015-11-07-lines-on-orthographic.html b/_posts/plotly_js/maps/lines-on-maps/2015-11-07-lines-on-orthographic.html
index 53767f2a2..5226d6dc1 100755
--- a/_posts/plotly_js/maps/lines-on-maps/2015-11-07-lines-on-orthographic.html
+++ b/_posts/plotly_js/maps/lines-on-maps/2015-11-07-lines-on-orthographic.html
@@ -68,5 +68,5 @@
         }
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 });
diff --git a/_posts/plotly_js/maps/map-view/2026-08-04-geo-autofit.html b/_posts/plotly_js/maps/map-view/2026-08-04-geo-autofit.html
new file mode 100644
index 000000000..8370f91d1
--- /dev/null
+++ b/_posts/plotly_js/maps/map-view/2026-08-04-geo-autofit.html
@@ -0,0 +1,41 @@
+---
+name: Auto-Fitting an Outline Map
+language: plotly_js
+suite: map-view
+order: 3
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  `layout.geo.fitbounds` defaults to `'locations'`, so an outline map frames the locations it plots rather than the
+  whole world. Set `fitbounds: false` to get the pre-v4 world view, or supply your own view attributes — `center`
+  and `projection.scale` always turn auto-fitting off, and `projection.rotation`, `lonaxis.range`, and
+  `lataxis.range` do too except on a scoped subplot with a clipped projection. See
+  [Map View and Zoom](/javascript/map-view/) for the full breakdown.
+
+  When `fitbounds` is active, the modebar's Reset view button returns to the fitted view rather than the world view.
+
+  Note that a location whose territory crosses the ±180° antimeridian — the United States (the Aleutian Islands),
+  Russia, Fiji, New Zealand, and Antarctica — spans most of the globe's longitude, so a figure that includes one is
+  fitted very wide. Set the view explicitly in that case.
+---
+var data = [{
+  type: 'choropleth',
+  locations: ['BRA', 'ARG', 'CHL', 'PER', 'COL', 'BOL'],
+  locationmode: 'ISO-3',
+  z: [6, 5, 4, 3, 2, 1],
+  colorscale: 'Blues',
+  showscale: false
+}];
+
+var layout = {
+  title: {text: 'Fitted to the Plotted Locations'},
+  geo: {
+    projection: {type: 'equirectangular'},
+    showcountries: true,
+    countrycolor: 'rgb(255, 255, 255)'
+  },
+  width: 700,
+  height: 450
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/maps/map-view/2026-08-04-geo-zoom-limits.html b/_posts/plotly_js/maps/map-view/2026-08-04-geo-zoom-limits.html
new file mode 100644
index 000000000..329a46961
--- /dev/null
+++ b/_posts/plotly_js/maps/map-view/2026-08-04-geo-zoom-limits.html
@@ -0,0 +1,48 @@
+---
+name: Limiting Zoom on Outline Maps
+language: plotly_js
+suite: map-view
+order: 4
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  `projection.minscale` and `projection.maxscale`, new in Plotly.js v4, clamp how far users can zoom a `geo` subplot.
+  Both are multipliers of `projection.scale`: `minscale: 0.5` stops zooming out past half the base scale and
+  `maxscale: 4` stops zooming in past four times it. The defaults — `minscale: 0` and no `maxscale` — leave zoom
+  unrestricted.
+
+  Try scrolling on the map below: it will not zoom out below half, or in beyond four times, its initial scale.
+
+  If the initial `projection.scale` falls outside the range you set, Plotly clamps it on the first render by dispatching
+  a zoom event, which emits one extra `plotly_relayout`. Listeners that distinguish user zooms from programmatic ones
+  should tolerate that single event at startup.
+---
+var data = [{
+  type: 'scattergeo',
+  mode: 'markers+text',
+  lon: [2.35, 13.4, 12.5, -3.7],
+  lat: [48.86, 52.52, 41.9, 40.42],
+  text: ['Paris', 'Berlin', 'Rome', 'Madrid'],
+  textposition: 'top center',
+  marker: {size: 10, color: '#636efa'}
+}];
+
+var layout = {
+  title: {text: 'Zoom Limited to 0.5x - 4x'},
+  geo: {
+    scope: 'europe',
+    resolution: 50,
+    showland: true,
+    landcolor: 'rgb(235, 235, 235)',
+    projection: {
+      scale: 1,
+      minscale: 0.5,
+      maxscale: 4
+    }
+  },
+  showlegend: false,
+  width: 700,
+  height: 500
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html b/_posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html
new file mode 100644
index 000000000..388805a1b
--- /dev/null
+++ b/_posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html
@@ -0,0 +1,57 @@
+---
+description: How to control the initial view of maps in JavaScript. Examples of auto-fitting a map to its data, setting an explicit view, and limiting how far users can zoom.
+display_as: maps
+language: plotly_js
+layout: base
+name: Map View and Zoom
+order: 12
+page_type: example_index
+permalink: javascript/map-view/
+thumbnail: thumbnail/county-level-choropleth.jpg
+---
+
+<p>Since Plotly.js v4, both outline-based <code>geo</code> subplots and tile-based <code>map</code> subplots auto-fit
+their initial view to the data they plot. Before v4, both opened on a default world view and you had to supply a view
+yourself to frame your data.</p>
+
+<p>Auto-fitting is controlled by <code>fitbounds</code>:</p>
+
+<ul>
+  <li><code>layout.geo.fitbounds</code> defaults to <code>'locations'</code> and also accepts
+    <code>'geojson'</code> (to frame the whole GeoJSON feature set rather than just the visible locations) and
+    <code>false</code>.</li>
+  <li><code>layout.map.fitbounds</code> defaults to <code>'locations'</code> and accepts <code>false</code>.
+    <code>choroplethmap</code> traces do not participate in auto-fitting, so a subplot containing one opens on the
+    default view.</li>
+</ul>
+
+<p>Supplying your own view attributes turns auto-fitting off for that subplot. On a tile map that means
+<code>map.center</code> or <code>map.zoom</code>. On an outline map, which attributes count depends on the subplot:</p>
+
+<table>
+  <tr><th>Subplot</th><th>Attributes that turn auto-fitting off</th></tr>
+  <tr>
+    <td>Any scope other than <code>'world'</code></td>
+    <td><code>center.lon</code>, <code>center.lat</code>, <code>projection.scale</code></td>
+  </tr>
+  <tr>
+    <td><code>'world'</code> scope, clipped projection (orthographic, conic conformal, stereographic, azimuthal, …)</td>
+    <td>the above, plus <code>projection.rotation.lon</code>, <code>projection.rotation.lat</code>,
+      <code>lonaxis.range</code>, <code>lataxis.range</code></td>
+  </tr>
+  <tr>
+    <td><code>'world'</code> scope, unclipped projection (equirectangular, mercator, robinson, …)</td>
+    <td>the above, plus <code>projection.rotation.lon</code>, <code>lonaxis.range</code>,
+      <code>lataxis.range</code></td>
+  </tr>
+</table>
+
+<p>Note the first row: on a scoped subplot whose projection is clipped, <code>lonaxis.range</code> and
+<code>lataxis.range</code> do <i>not</i> turn auto-fitting off — they still clip the drawing region, but the view is
+centered on the data. Set <code>fitbounds: false</code> to honor the ranges as the view.</p>
+
+<p>Setting <code>fitbounds: false</code> without supplying a view restores the pre-v4 default view. The
+<code>'albers usa'</code>, <code>'craig'</code>, and <code>'satellite'</code> projections never auto-fit.</p>
+
+{% assign examples = site.posts | where:"language","plotly_js" | where:"suite","map-view" | sort: "order" %}
+{% include posts/auto_examples.html examples=examples %}
diff --git a/_posts/plotly_js/maps/map-view/2026-08-04-tile-map-autofit.html b/_posts/plotly_js/maps/map-view/2026-08-04-tile-map-autofit.html
new file mode 100644
index 000000000..f85aa63a1
--- /dev/null
+++ b/_posts/plotly_js/maps/map-view/2026-08-04-tile-map-autofit.html
@@ -0,0 +1,32 @@
+---
+name: Auto-Fitting a Tile Map to Data
+language: plotly_js
+suite: map-view
+order: 1
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  With no `center` or `zoom` given, a `map` subplot frames the trace data on the first render. It re-fits when the data
+  changes — through `Plotly.restyle` of `lon`/`lat`, `Plotly.addTraces`, or `Plotly.deleteTraces` — until the user pans,
+  zooms, rotates, or tilts the map, after which the chosen view is preserved. Data that straddles the antimeridian is
+  framed the short way around, not across the whole globe.
+---
+var data = [{
+  type: 'scattermap',
+  mode: 'markers+text',
+  lon: [-122.4, -73.9, -87.6],
+  lat: [37.8, 40.7, 41.9],
+  text: ['San Francisco', 'New York', 'Chicago'],
+  textposition: 'top right',
+  marker: {size: 12, color: '#d62728'}
+}];
+
+var layout = {
+  map: {style: 'basic'},
+  showlegend: false,
+  width: 700,
+  height: 450,
+  margin: {t: 30, b: 0, l: 0, r: 0}
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/maps/map-view/2026-08-04-tile-map-explicit-view.html b/_posts/plotly_js/maps/map-view/2026-08-04-tile-map-explicit-view.html
new file mode 100644
index 000000000..9b0fe4efe
--- /dev/null
+++ b/_posts/plotly_js/maps/map-view/2026-08-04-tile-map-explicit-view.html
@@ -0,0 +1,37 @@
+---
+name: Setting an Explicit Tile Map View
+language: plotly_js
+suite: map-view
+order: 2
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  Passing `map.center` or `map.zoom` opts the subplot out of auto-fitting and opens it on exactly the view you give,
+  even if that view is the default `zoom: 1` centered on `(0, 0)`. Setting `map.fitbounds: false` without a view has
+  the same effect as the pre-v4 default: a world view at `zoom: 1`.
+
+  `map.bounds`, which restricts how far users can pan, is independent of auto-fitting and can be combined with either.
+---
+var data = [{
+  type: 'scattermap',
+  mode: 'markers+text',
+  lon: [-122.4, -73.9, -87.6],
+  lat: [37.8, 40.7, 41.9],
+  text: ['San Francisco', 'New York', 'Chicago'],
+  textposition: 'top right',
+  marker: {size: 12, color: '#d62728'}
+}];
+
+var layout = {
+  map: {
+    style: 'basic',
+    center: {lon: -98, lat: 39},
+    zoom: 2.5
+  },
+  showlegend: false,
+  width: 700,
+  height: 450,
+  margin: {t: 30, b: 0, l: 0, r: 0}
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html b/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html
index 8105293a3..e26c2d6ca 100644
--- a/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html
+++ b/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html
@@ -10,19 +10,26 @@
 thumbnail: thumbnail/area.jpg
 ---
 
-<p>With the release of Plotly.js v2.35.0, we are introducing a new set of trace types for maps with tile underlays:</p>
+<p>Plotly.js v2.35.0 introduced a set of trace types for maps with tile underlays:</p>
 
 <ul>
-    <li>Choroplethmap</li>
-    <li>Scattermap</li>
-    <li>Densitymap</li>
+    <li><code>Choroplethmap</code></li>
+    <li><code>Scattermap</code></li>
+    <li><code>Densitymap</code></li>
 </ul>
 
-<p>These traces replace the existing Mapbox traces, <code>Choroplethmapbox</code>, <code>Scattermapbox</code>,
-    <code>Densitymapbox</code>, but use <a href="https://maplibre.org">MapLibre</a> as the map renderer rather than
+<p>These traces replace the Mapbox traces, <code>Choroplethmapbox</code>, <code>Scattermapbox</code>, and
+    <code>Densitymapbox</code>, and use <a href="https://maplibre.org">MapLibre</a> as the map renderer rather than
     Mapbox.
 </p>
 
+<p><strong>The Mapbox traces, the <code>layout.mapbox</code> subplot, and the <code>mapboxAccessToken</code> config
+    option were removed in Plotly.js v4</strong>, along with the <code>plotly-mapbox.min.js</code> partial bundle and
+    the <code>zoomInMapbox</code>, <code>zoomOutMapbox</code>, and <code>resetViewMapbox</code> modebar buttons (use
+    <code>plotly-map.min.js</code> and <code>zoomInMap</code>, <code>zoomOutMap</code>, <code>resetViewMap</code>).
+    If you are upgrading to v4, follow the steps below first. See
+    <a href="/javascript/guides/migrating-to-v4/">Migrating to Plotly.js v4</a> for the rest of the upgrade.</p>
+
 <p>When switching to the new traces, keep an eye out for improved rendering performance, WebGL2 support, and over time,
     improved features in the Plotly map traces inherited from the MapLibre renderer, including projection support, globe
     views, terrain support, and support for modern mapping standards.</p>
@@ -48,9 +55,14 @@
         <code>outdoors</code>, <code>light</code>, <code>dark</code>, <code>satellite</code>, and
         <code>satellite-streets</code> styles,
         using Mapbox styling. These style names are still available, but they now reference slightly different styles
-        provided by other tools.
+        provided by other tools. The three Stamen styles (<code>stamen-terrain</code>, <code>stamen-toner</code>, and
+        <code>stamen-watercolor</code>) are not available, because Stamen tiles are served by Stadia Maps and require
+        an API key — pass the URL of a style definition to use them.
     </li>
+    <li>Remove <code>mapboxAccessToken</code> from your config, and any
+        <code>mapbox://styles/mapbox/...</code> style URLs, neither of which is supported. Custom MapLibre and Mapbox
+        JSON style URLs still work.</li>
 </ol>
 
 <p>Note that Mapbox API keys are no longer required for Plotly-provided styles, but using external styles in your Plotly
-    maps remains supported with the existing API.</p>
\ No newline at end of file
+    maps remains supported with the existing API.</p>
diff --git a/_posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-example.html b/_posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-example.html
index 0284c4109..4e358366f 100644
--- a/_posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-example.html
+++ b/_posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-example.html
@@ -7,6 +7,13 @@
 arrangement: horizontal
 markdown_content: |
   Set `locationmode: 'country names'` to use full country names in `locations`.
+
+  Names are resolved by [country-iso-search](https://github.com/plotly/country-iso-search), which matches a country's
+  name, its ISO-2 and UN M49 codes, and a curated set of aliases — historical and native names, and common alternates.
+  Matching ignores case, accents, and punctuation, so `'Cote d'Ivoire'`, `'Türkiye'`, and `'St. Kitts and Nevis'` all
+  resolve. See the library's
+  [country list](https://github.com/plotly/country-iso-search/blob/main/src/countries.ts) for every accepted name and
+  alias. A name that doesn't resolve is logged to the console and that location is skipped.
 ---
 var data = [{
     type: 'choropleth',
diff --git a/_posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-warning.html b/_posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-warning.html
deleted file mode 100644
index d243f2a1e..000000000
--- a/_posts/plotly_js/maps/outline-map-locations/2019-07-03-country-names-warning.html
+++ /dev/null
@@ -1,10 +0,0 @@
----
-language: plotly_js
-suite: outline-map-locations
-order: 3.5
-sitemap: false
-arrangement: horizontal
-markdown_content: |
-  > How Plotly matches 'country names' will change in a future version. Matching will become stricter and some country names may no longer match. We recommend using `locationmode: 'ISO-3'` with ISO codes for `locations` to ensure consistent behavior across versions.
----
-
diff --git a/_posts/plotly_js/maps/outline-map-locations/2019-07-03-iso3-table.html b/_posts/plotly_js/maps/outline-map-locations/2019-07-03-iso3-table.html
index 3c5f16104..4e93a8525 100644
--- a/_posts/plotly_js/maps/outline-map-locations/2019-07-03-iso3-table.html
+++ b/_posts/plotly_js/maps/outline-map-locations/2019-07-03-iso3-table.html
@@ -8,6 +8,15 @@
 markdown_content: |
   The following ISO codes are supported when `locationmode='ISO-3'`:
 
+  Codes marked <sup>&#8224;</sup> are only present in the higher-resolution map data. Since
+  [`geo.resolution`](https://plotly.com/javascript/reference/layout/geo/#layout-geo-resolution) defaults to `110`,
+  plotting one of those locations also needs `resolution: 50` on the `geo` subplot, or the location is skipped and
+  nothing is drawn for it.
+
+  Rows marked *(grouped with ...)* are territories the map data draws inside another country's feature, listed here
+  so the code is easy to find. Plotting one shades that whole country, and the territory name itself is not accepted
+  as a value for `locationmode: 'country names'`.
+
   <table style="text-align: left; margin-left: 0; margin-right: auto;">
   <thead>
   <tr>
@@ -21,38 +30,38 @@
   <tr><td>Åland Islands</td><td>ALA</td></tr>
   <tr><td>Albania</td><td>ALB</td></tr>
   <tr><td>Algeria</td><td>DZA</td></tr>
-  <tr><td>American Samoa</td><td>ASM</td></tr>
-  <tr><td>Andorra</td><td>AND</td></tr>
+  <tr><td>American Samoa</td><td>ASM <sup>&#8224;</sup></td></tr>
+  <tr><td>Andorra</td><td>AND <sup>&#8224;</sup></td></tr>
   <tr><td>Angola</td><td>AGO</td></tr>
-  <tr><td>Anguilla</td><td>AIA</td></tr>
+  <tr><td>Anguilla</td><td>AIA <sup>&#8224;</sup></td></tr>
   <tr><td>Antarctica</td><td>ATA</td></tr>
-  <tr><td>Antigua and Barbuda</td><td>ATG</td></tr>
+  <tr><td>Antigua and Barbuda</td><td>ATG <sup>&#8224;</sup></td></tr>
   <tr><td>Argentina</td><td>ARG</td></tr>
   <tr><td>Armenia</td><td>ARM</td></tr>
-  <tr><td>Aruba</td><td>ABW</td></tr>
+  <tr><td>Aruba</td><td>ABW <sup>&#8224;</sup></td></tr>
   <tr><td>Arunachal Pradesh</td><td>XAP</td></tr>
   <tr><td>Australia</td><td>AUS</td></tr>
   <tr><td>Austria</td><td>AUT</td></tr>
   <tr><td>Azerbaijan</td><td>AZE</td></tr>
-  <tr><td>Azores Islands</td><td>PRT</td></tr>
+  <tr><td>Azores Islands <em>(grouped with Portugal)</em></td><td>PRT</td></tr>
   <tr><td>Bahamas</td><td>BHS</td></tr>
-  <tr><td>Bahrain</td><td>BHR</td></tr>
+  <tr><td>Bahrain</td><td>BHR <sup>&#8224;</sup></td></tr>
   <tr><td>Bangladesh</td><td>BGD</td></tr>
-  <tr><td>Barbados</td><td>BRB</td></tr>
+  <tr><td>Barbados</td><td>BRB <sup>&#8224;</sup></td></tr>
   <tr><td>Belarus</td><td>BLR</td></tr>
   <tr><td>Belgium</td><td>BEL</td></tr>
   <tr><td>Belize</td><td>BLZ</td></tr>
   <tr><td>Benin</td><td>BEN</td></tr>
-  <tr><td>Bermuda</td><td>BMU</td></tr>
+  <tr><td>Bermuda</td><td>BMU <sup>&#8224;</sup></td></tr>
   <tr><td>Bhutan</td><td>BTN</td></tr>
   <tr><td>Bir Tawil</td><td>XBT</td></tr>
   <tr><td>Bolivia (Plurinational State of)</td><td>BOL</td></tr>
-  <tr><td>Bonaire</td><td>BES</td></tr>
+  <tr><td>Bonaire</td><td>BES <sup>&#8224;</sup></td></tr>
   <tr><td>Bosnia and Herzegovina</td><td>BIH</td></tr>
   <tr><td>Botswana</td><td>BWA</td></tr>
-  <tr><td>Bouvet Island</td><td>BVT</td></tr>
+  <tr><td>Bouvet Island</td><td>BVT <sup>&#8224;</sup></td></tr>
   <tr><td>Brazil</td><td>BRA</td></tr>
-  <tr><td>British Virgin Islands</td><td>VGB</td></tr>
+  <tr><td>British Virgin Islands</td><td>VGB <sup>&#8224;</sup></td></tr>
   <tr><td>Brunei Darussalam</td><td>BRN</td></tr>
   <tr><td>Bulgaria</td><td>BGR</td></tr>
   <tr><td>Burkina Faso</td><td>BFA</td></tr>
@@ -61,24 +70,24 @@
   <tr><td>Cambodia</td><td>KHM</td></tr>
   <tr><td>Cameroon</td><td>CMR</td></tr>
   <tr><td>Canada</td><td>CAN</td></tr>
-  <tr><td>Canary Islands</td><td>ESP</td></tr>
-  <tr><td>Cayman Islands</td><td>CYM</td></tr>
+  <tr><td>Canary Islands <em>(grouped with Spain)</em></td><td>ESP</td></tr>
+  <tr><td>Cayman Islands</td><td>CYM <sup>&#8224;</sup></td></tr>
   <tr><td>Central African Republic</td><td>CAF</td></tr>
   <tr><td>Chad</td><td>TCD</td></tr>
-  <tr><td>Chagos Archipelago</td><td>MUS</td></tr>
+  <tr><td>Chagos Archipelago <em>(grouped with Mauritius)</em></td><td>MUS</td></tr>
   <tr><td>Chile</td><td>CHL</td></tr>
   <tr><td>China</td><td>CHN</td></tr>
-  <tr><td>Christmas Island</td><td>CXR</td></tr>
-  <tr><td>Cocos (Keeling) Islands</td><td>CCK</td></tr>
+  <tr><td>Christmas Island</td><td>CXR <sup>&#8224;</sup></td></tr>
+  <tr><td>Cocos (Keeling) Islands</td><td>CCK <sup>&#8224;</sup></td></tr>
   <tr><td>Colombia</td><td>COL</td></tr>
   <tr><td>Comoros</td><td>COM</td></tr>
   <tr><td>Congo</td><td>COG</td></tr>
-  <tr><td>Cook Islands</td><td>COK</td></tr>
+  <tr><td>Cook Islands</td><td>COK <sup>&#8224;</sup></td></tr>
   <tr><td>Costa Rica</td><td>CRI</td></tr>
   <tr><td>Côte d'Ivoire</td><td>CIV</td></tr>
   <tr><td>Croatia</td><td>HRV</td></tr>
   <tr><td>Cuba</td><td>CUB</td></tr>
-  <tr><td>Curaçao</td><td>CUW</td></tr>
+  <tr><td>Curaçao</td><td>CUW <sup>&#8224;</sup></td></tr>
   <tr><td>Cyprus</td><td>CYP</td></tr>
   <tr><td>Czechia</td><td>CZE</td></tr>
   <tr><td>Democratic People's Republic of Korea</td><td>PRK</td></tr>
@@ -96,7 +105,7 @@
   <tr><td>Eswatini</td><td>SWZ</td></tr>
   <tr><td>Ethiopia</td><td>ETH</td></tr>
   <tr><td>Falkland Islands (Malvinas)</td><td>FLK</td></tr>
-  <tr><td>Faroe Islands</td><td>FRO</td></tr>
+  <tr><td>Faroe Islands</td><td>FRO <sup>&#8224;</sup></td></tr>
   <tr><td>Fiji</td><td>FJI</td></tr>
   <tr><td>Finland</td><td>FIN</td></tr>
   <tr><td>France</td><td>FRA</td></tr>
@@ -104,28 +113,28 @@
   <tr><td>French Polynesia</td><td>PYF</td></tr>
   <tr><td>French Southern Territories</td><td>ATF</td></tr>
   <tr><td>Gabon</td><td>GAB</td></tr>
-  <tr><td>Galápagos Islands</td><td>ECU</td></tr>
+  <tr><td>Galápagos Islands <em>(grouped with Ecuador)</em></td><td>ECU</td></tr>
   <tr><td>Gambia</td><td>GMB</td></tr>
-  <tr><td>Gaza</td><td>PSE</td></tr>
+  <tr><td>Gaza <em>(grouped with State of Palestine)</em></td><td>PSE</td></tr>
   <tr><td>Georgia</td><td>GEO</td></tr>
   <tr><td>Germany</td><td>DEU</td></tr>
   <tr><td>Ghana</td><td>GHA</td></tr>
-  <tr><td>Gibraltar</td><td>GIB</td></tr>
+  <tr><td>Gibraltar</td><td>GIB <sup>&#8224;</sup></td></tr>
   <tr><td>Greece</td><td>GRC</td></tr>
   <tr><td>Greenland</td><td>GRL</td></tr>
-  <tr><td>Grenada</td><td>GRD</td></tr>
+  <tr><td>Grenada</td><td>GRD <sup>&#8224;</sup></td></tr>
   <tr><td>Guadeloupe</td><td>GLP</td></tr>
   <tr><td>Guam</td><td>GUM</td></tr>
   <tr><td>Guatemala</td><td>GTM</td></tr>
-  <tr><td>Guernsey</td><td>GGY</td></tr>
+  <tr><td>Guernsey</td><td>GGY <sup>&#8224;</sup></td></tr>
   <tr><td>Guinea</td><td>GIN</td></tr>
   <tr><td>Guinea-Bissau</td><td>GNB</td></tr>
   <tr><td>Guyana</td><td>GUY</td></tr>
   <tr><td>Haiti</td><td>HTI</td></tr>
   <tr><td>Halaib Triangle</td><td>XHT</td></tr>
-  <tr><td>Heard Island and McDonald Islands</td><td>HMD</td></tr>
+  <tr><td>Heard Island and McDonald Islands</td><td>HMD <sup>&#8224;</sup></td></tr>
   <tr><td>Honduras</td><td>HND</td></tr>
-  <tr><td>Hong Kong</td><td>HKG</td></tr>
+  <tr><td>Hong Kong</td><td>HKG <sup>&#8224;</sup></td></tr>
   <tr><td>Hungary</td><td>HUN</td></tr>
   <tr><td>Iceland</td><td>ISL</td></tr>
   <tr><td>Ilemi Triangle</td><td>XIT</td></tr>
@@ -134,18 +143,18 @@
   <tr><td>Iran (Islamic Republic of)</td><td>IRN</td></tr>
   <tr><td>Iraq</td><td>IRQ</td></tr>
   <tr><td>Ireland</td><td>IRL</td></tr>
-  <tr><td>Isle of Man</td><td>IMN</td></tr>
+  <tr><td>Isle of Man</td><td>IMN <sup>&#8224;</sup></td></tr>
   <tr><td>Israel</td><td>ISR</td></tr>
   <tr><td>Italy</td><td>ITA</td></tr>
   <tr><td>Jamaica</td><td>JAM</td></tr>
   <tr><td>Jammu and Kashmir</td><td>XJK</td></tr>
   <tr><td>Japan</td><td>JPN</td></tr>
-  <tr><td>Jersey</td><td>JEY</td></tr>
+  <tr><td>Jersey</td><td>JEY <sup>&#8224;</sup></td></tr>
   <tr><td>Jordan</td><td>JOR</td></tr>
   <tr><td>Kazakhstan</td><td>KAZ</td></tr>
   <tr><td>Kenya</td><td>KEN</td></tr>
   <tr><td>Kingdom of the Netherlands</td><td>NLD</td></tr>
-  <tr><td>Kiribati</td><td>KIR</td></tr>
+  <tr><td>Kiribati</td><td>KIR <sup>&#8224;</sup></td></tr>
   <tr><td>Kuwait</td><td>KWT</td></tr>
   <tr><td>Kyrgyzstan</td><td>KGZ</td></tr>
   <tr><td>Lao People's Democratic Republic</td><td>LAO</td></tr>
@@ -154,53 +163,53 @@
   <tr><td>Lesotho</td><td>LSO</td></tr>
   <tr><td>Liberia</td><td>LBR</td></tr>
   <tr><td>Libya</td><td>LBY</td></tr>
-  <tr><td>Liechtenstein</td><td>LIE</td></tr>
+  <tr><td>Liechtenstein</td><td>LIE <sup>&#8224;</sup></td></tr>
   <tr><td>Lithuania</td><td>LTU</td></tr>
   <tr><td>Luxembourg</td><td>LUX</td></tr>
-  <tr><td>Macao</td><td>MAC</td></tr>
+  <tr><td>Macao</td><td>MAC <sup>&#8224;</sup></td></tr>
   <tr><td>Madagascar</td><td>MDG</td></tr>
-  <tr><td>Madeira Island</td><td>PRT</td></tr>
+  <tr><td>Madeira Island <em>(grouped with Portugal)</em></td><td>PRT</td></tr>
   <tr><td>Malawi</td><td>MWI</td></tr>
   <tr><td>Malaysia</td><td>MYS</td></tr>
-  <tr><td>Maldives</td><td>MDV</td></tr>
+  <tr><td>Maldives</td><td>MDV <sup>&#8224;</sup></td></tr>
   <tr><td>Mali</td><td>MLI</td></tr>
-  <tr><td>Malta</td><td>MLT</td></tr>
-  <tr><td>Marshall Islands</td><td>MHL</td></tr>
+  <tr><td>Malta</td><td>MLT <sup>&#8224;</sup></td></tr>
+  <tr><td>Marshall Islands</td><td>MHL <sup>&#8224;</sup></td></tr>
   <tr><td>Martinique</td><td>MTQ</td></tr>
   <tr><td>Mauritania</td><td>MRT</td></tr>
   <tr><td>Mauritius</td><td>MUS</td></tr>
-  <tr><td>Mayotte</td><td>MYT</td></tr>
+  <tr><td>Mayotte</td><td>MYT <sup>&#8224;</sup></td></tr>
   <tr><td>Mexico</td><td>MEX</td></tr>
-  <tr><td>Micronesia (Federated States of)</td><td>FSM</td></tr>
-  <tr><td>Monaco</td><td>MCO</td></tr>
+  <tr><td>Micronesia (Federated States of)</td><td>FSM <sup>&#8224;</sup></td></tr>
+  <tr><td>Monaco</td><td>MCO <sup>&#8224;</sup></td></tr>
   <tr><td>Mongolia</td><td>MNG</td></tr>
   <tr><td>Montenegro</td><td>MNE</td></tr>
-  <tr><td>Montserrat</td><td>MSR</td></tr>
+  <tr><td>Montserrat</td><td>MSR <sup>&#8224;</sup></td></tr>
   <tr><td>Morocco</td><td>MAR</td></tr>
   <tr><td>Mozambique</td><td>MOZ</td></tr>
   <tr><td>Myanmar</td><td>MMR</td></tr>
   <tr><td>Namibia</td><td>NAM</td></tr>
-  <tr><td>Nauru</td><td>NRU</td></tr>
+  <tr><td>Nauru</td><td>NRU <sup>&#8224;</sup></td></tr>
   <tr><td>Nepal</td><td>NPL</td></tr>
   <tr><td>New Caledonia</td><td>NCL</td></tr>
   <tr><td>New Zealand</td><td>NZL</td></tr>
   <tr><td>Nicaragua</td><td>NIC</td></tr>
   <tr><td>Niger</td><td>NER</td></tr>
   <tr><td>Nigeria</td><td>NGA</td></tr>
-  <tr><td>Niue</td><td>NIU</td></tr>
-  <tr><td>Norfolk Island</td><td>NFK</td></tr>
+  <tr><td>Niue</td><td>NIU <sup>&#8224;</sup></td></tr>
+  <tr><td>Norfolk Island</td><td>NFK <sup>&#8224;</sup></td></tr>
   <tr><td>North Macedonia</td><td>MKD</td></tr>
-  <tr><td>Northern Mariana Islands</td><td>MNP</td></tr>
+  <tr><td>Northern Mariana Islands</td><td>MNP <sup>&#8224;</sup></td></tr>
   <tr><td>Norway</td><td>NOR</td></tr>
   <tr><td>Oman</td><td>OMN</td></tr>
   <tr><td>Pakistan</td><td>PAK</td></tr>
-  <tr><td>Palau</td><td>PLW</td></tr>
+  <tr><td>Palau</td><td>PLW <sup>&#8224;</sup></td></tr>
   <tr><td>Panama</td><td>PAN</td></tr>
   <tr><td>Papua New Guinea</td><td>PNG</td></tr>
   <tr><td>Paraguay</td><td>PRY</td></tr>
   <tr><td>Peru</td><td>PER</td></tr>
   <tr><td>Philippines</td><td>PHL</td></tr>
-  <tr><td>Pitcairn</td><td>PCN</td></tr>
+  <tr><td>Pitcairn</td><td>PCN <sup>&#8224;</sup></td></tr>
   <tr><td>Poland</td><td>POL</td></tr>
   <tr><td>Portugal</td><td>PRT</td></tr>
   <tr><td>Puerto Rico</td><td>PRI</td></tr>
@@ -211,24 +220,24 @@
   <tr><td>Romania</td><td>ROU</td></tr>
   <tr><td>Russian Federation</td><td>RUS</td></tr>
   <tr><td>Rwanda</td><td>RWA</td></tr>
-  <tr><td>Saba</td><td>BES</td></tr>
-  <tr><td>Saint Barthélemy</td><td>BLM</td></tr>
-  <tr><td>Saint Helena</td><td>SHN</td></tr>
-  <tr><td>Saint Kitts and Nevis</td><td>KNA</td></tr>
-  <tr><td>Saint Lucia</td><td>LCA</td></tr>
-  <tr><td>Saint Martin</td><td>MAF</td></tr>
-  <tr><td>Saint Pierre and Miquelon</td><td>SPM</td></tr>
-  <tr><td>Saint Vincent and the Grenadines</td><td>VCT</td></tr>
+  <tr><td>Saba</td><td>BES <sup>&#8224;</sup></td></tr>
+  <tr><td>Saint Barthélemy</td><td>BLM <sup>&#8224;</sup></td></tr>
+  <tr><td>Saint Helena</td><td>SHN <sup>&#8224;</sup></td></tr>
+  <tr><td>Saint Kitts and Nevis</td><td>KNA <sup>&#8224;</sup></td></tr>
+  <tr><td>Saint Lucia</td><td>LCA <sup>&#8224;</sup></td></tr>
+  <tr><td>Saint Martin</td><td>MAF <sup>&#8224;</sup></td></tr>
+  <tr><td>Saint Pierre and Miquelon</td><td>SPM <sup>&#8224;</sup></td></tr>
+  <tr><td>Saint Vincent and the Grenadines</td><td>VCT <sup>&#8224;</sup></td></tr>
   <tr><td>Samoa</td><td>WSM</td></tr>
   <tr><td>Sao Tome and Principe</td><td>STP</td></tr>
   <tr><td>Saudi Arabia</td><td>SAU</td></tr>
   <tr><td>Senegal</td><td>SEN</td></tr>
   <tr><td>Serbia</td><td>SRB</td></tr>
-  <tr><td>Seychelles</td><td>SYC</td></tr>
+  <tr><td>Seychelles</td><td>SYC <sup>&#8224;</sup></td></tr>
   <tr><td>Sierra Leone</td><td>SLE</td></tr>
-  <tr><td>Singapore</td><td>SGP</td></tr>
-  <tr><td>Sint Eustatius</td><td>BES</td></tr>
-  <tr><td>Sint Maarten</td><td>SXM</td></tr>
+  <tr><td>Singapore</td><td>SGP <sup>&#8224;</sup></td></tr>
+  <tr><td>Sint Eustatius</td><td>BES <sup>&#8224;</sup></td></tr>
+  <tr><td>Sint Maarten</td><td>SXM <sup>&#8224;</sup></td></tr>
   <tr><td>Slovakia</td><td>SVK</td></tr>
   <tr><td>Slovenia</td><td>SVN</td></tr>
   <tr><td>Solomon Islands</td><td>SLB</td></tr>
@@ -249,27 +258,27 @@
   <tr><td>Thailand</td><td>THA</td></tr>
   <tr><td>Timor-Leste</td><td>TLS</td></tr>
   <tr><td>Togo</td><td>TGO</td></tr>
-  <tr><td>Tokelau</td><td>TKL</td></tr>
-  <tr><td>Tonga</td><td>TON</td></tr>
+  <tr><td>Tokelau</td><td>TKL <sup>&#8224;</sup></td></tr>
+  <tr><td>Tonga</td><td>TON <sup>&#8224;</sup></td></tr>
   <tr><td>Trinidad and Tobago</td><td>TTO</td></tr>
   <tr><td>Tunisia</td><td>TUN</td></tr>
   <tr><td>Türkiye</td><td>TUR</td></tr>
   <tr><td>Turkmenistan</td><td>TKM</td></tr>
-  <tr><td>Turks and Caicos Islands</td><td>TCA</td></tr>
-  <tr><td>Tuvalu</td><td>TUV</td></tr>
+  <tr><td>Turks and Caicos Islands</td><td>TCA <sup>&#8224;</sup></td></tr>
+  <tr><td>Tuvalu</td><td>TUV <sup>&#8224;</sup></td></tr>
   <tr><td>Uganda</td><td>UGA</td></tr>
   <tr><td>Ukraine</td><td>UKR</td></tr>
   <tr><td>United Arab Emirates</td><td>ARE</td></tr>
   <tr><td>United Kingdom of Great Britain and Northern Ireland</td><td>GBR</td></tr>
   <tr><td>United Republic of Tanzania</td><td>TZA</td></tr>
   <tr><td>United States of America</td><td>USA</td></tr>
-  <tr><td>United States Virgin Islands</td><td>VIR</td></tr>
+  <tr><td>United States Virgin Islands</td><td>VIR <sup>&#8224;</sup></td></tr>
   <tr><td>Uruguay</td><td>URY</td></tr>
   <tr><td>Uzbekistan</td><td>UZB</td></tr>
   <tr><td>Vanuatu</td><td>VUT</td></tr>
   <tr><td>Venezuela (Bolivarian Republic of)</td><td>VEN</td></tr>
   <tr><td>Viet Nam</td><td>VNM</td></tr>
-  <tr><td>West Bank</td><td>PSE</td></tr>
+  <tr><td>West Bank <em>(grouped with State of Palestine)</em></td><td>PSE</td></tr>
   <tr><td>Western Sahara</td><td>ESH</td></tr>
   <tr><td>Yemen</td><td>YEM</td></tr>
   <tr><td>Zambia</td><td>ZMB</td></tr>
@@ -279,4 +288,3 @@
 
   [View full list of ISO-3 codes](https://en.wikipedia.org/wiki/ISO_3166-1_alpha-3)
 ---
-
diff --git a/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-12-US-airport-map.html b/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-12-US-airport-map.html
index 8eca7fd36..3b15fe899 100644
--- a/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-12-US-airport-map.html
+++ b/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-12-US-airport-map.html
@@ -59,6 +59,6 @@
         }
     };
 
-    Plotly.newPlot("myDiv", data, layout, {showLink: false});
+    Plotly.newPlot("myDiv", data, layout);
 
 });
diff --git a/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-precipitation-map.html b/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-precipitation-map.html
index 72305d527..30db69748 100644
--- a/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-precipitation-map.html
+++ b/_posts/plotly_js/maps/scatter-plot-on-maps/2015-08-15-north-america-precipitation-map.html
@@ -46,6 +46,7 @@
     var layout = {
       geo:{
         scope: 'north america',
+        fitbounds: false,
         showland: true,
         landcolor: 'rgb(212,212,212)',
         subunitcolor: 'rgb(255,255,255)',
@@ -61,18 +62,18 @@
             long: -100
           }
         },
-      },
-      longaxis: {
-        showgrid: true,
-        gridwidth: 0.5,
-        range: [ -140.0, -55.0 ],
-        dtick: 5
-      },
-      lataxis: {
-        showgrid: true,
-        gridwidth: 0.5,
-        range: [ 20.0, 60.0 ],
-        dtick: 5
+        lonaxis: {
+          showgrid: true,
+          gridwidth: 0.5,
+          range: [ -140.0, -55.0 ],
+          dtick: 5
+        },
+        lataxis: {
+          showgrid: true,
+          gridwidth: 0.5,
+          range: [ 20.0, 60.0 ],
+          dtick: 5
+        }
       },
       title: {text: 'North America Precipitation'},
       width: 600,
diff --git a/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_lines.html b/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_lines.html
index 8b4f827d9..1ca987c2b 100644
--- a/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_lines.html
+++ b/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_lines.html
@@ -66,6 +66,6 @@
       showlegend: false
    };
 
-  Plotly.newPlot("myDiv", data, layout, {showLink: false});
+  Plotly.newPlot("myDiv", data, layout);
 
 });
diff --git a/_posts/plotly_js/maps/scattermapbox/2019-09-02-symbols.html b/_posts/plotly_js/maps/scattermapbox/2019-09-02-symbols.html
index a66df21a8..dddc7149b 100644
--- a/_posts/plotly_js/maps/scattermapbox/2019-09-02-symbols.html
+++ b/_posts/plotly_js/maps/scattermapbox/2019-09-02-symbols.html
@@ -6,7 +6,9 @@
 sitemap: false
 arrangement: horizontal
 markdown_content: |
-     This example uses [symbol attribute](https://plotly.com/javascript/reference/scattermap/#scattermap-marker-symbol) to set the marker symbol.
+     This example uses the [symbol attribute](https://plotly.com/javascript/reference/scattermap/#scattermap-marker-symbol) to set the marker symbol.
+     Symbol names come from the [Maki icon set](https://labs.mapbox.com/maki-icons/) (updated to Maki 8 in Plotly.js v4).
+     Since v4, icons are tinted with `marker.color`; earlier versions always drew them in black.
 ---
 var data = [
 	{
@@ -14,7 +16,7 @@
 		mode: "markers+text+lines",
 		lon: [-75, -80, -50],
 		lat: [45, 20, -20],
-		marker: { size: 20, symbol: ["bus", "harbor", "airport"] },
+		marker: { size: 20, color: "black", symbol: ["bus", "harbor", "airport"] },
 		text: ["Bus", "Harbor", "Airport"],
 		textposition: "bottom right"
 	}
diff --git a/_posts/plotly_js/scientific/quiver/2026-08-04-basic-quiver.html b/_posts/plotly_js/scientific/quiver/2026-08-04-basic-quiver.html
new file mode 100644
index 000000000..e2b4d3d33
--- /dev/null
+++ b/_posts/plotly_js/scientific/quiver/2026-08-04-basic-quiver.html
@@ -0,0 +1,27 @@
+---
+name: Basic Quiver Plot
+language: plotly_js
+suite: quiver
+order: 1
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  Each arrow is anchored at an `(x, y)` position and points along the `(u, v)` vector given for that position.
+---
+var data = [{
+  type: 'quiver',
+  x: [0, 1, 2, 0, 1, 2],
+  y: [0, 0, 0, 1, 1, 1],
+  u: [1, 0.5, 0, 0.5, 0, -0.5],
+  v: [0, 0.5, 1, 0.5, 1, 0.5]
+}];
+
+var layout = {
+  title: {text: 'Basic Quiver Plot'},
+  xaxis: {title: {text: 'x'}},
+  yaxis: {title: {text: 'y'}},
+  width: 600,
+  height: 400
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-anchor-size.html b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-anchor-size.html
new file mode 100644
index 000000000..6f3dd4946
--- /dev/null
+++ b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-anchor-size.html
@@ -0,0 +1,47 @@
+---
+name: Arrow Anchor and Length
+language: plotly_js
+suite: quiver
+order: 2
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  This example plots the rotational field `(u, v) = (-y, x)` on a grid. `anchor: 'center'` centers each arrow on its
+  grid point instead of starting it there, and `sizeref` scales every arrow by the same factor. With the default
+  `sizemode: 'scaled'`, arrow lengths are normalized against the longest vector in the field, so the grid stays legible
+  however large the underlying values are.
+---
+var x = [];
+var y = [];
+var u = [];
+var v = [];
+
+for (var i = -2; i <= 2; i++) {
+  for (var j = -2; j <= 2; j++) {
+    x.push(i);
+    y.push(j);
+    u.push(-j);
+    v.push(i);
+  }
+}
+
+var data = [{
+  type: 'quiver',
+  x: x,
+  y: y,
+  u: u,
+  v: v,
+  anchor: 'center',
+  sizeref: 0.8,
+  marker: {color: '#636efa'}
+}];
+
+var layout = {
+  title: {text: 'Rotational Field, Arrows Centered on Each Point'},
+  xaxis: {title: {text: 'x'}},
+  yaxis: {title: {text: 'y'}, scaleanchor: 'x'},
+  width: 600,
+  height: 500
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-color.html b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-color.html
new file mode 100644
index 000000000..f94bf288e
--- /dev/null
+++ b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-color.html
@@ -0,0 +1,57 @@
+---
+name: Color Arrows by a Scalar Field
+language: plotly_js
+suite: quiver
+order: 3
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  Pass `marker.color` an array with one value per arrow, together with the usual colorscale attributes
+  (`marker.colorscale`, `marker.cmin`, `marker.cmax`, `marker.showscale`, `marker.colorbar`), to color each arrow by
+  that value. Here the arrows are colored by their own magnitude. If you enable a colorscale without supplying a
+  `marker.color` array, arrows are colored by vector magnitude automatically. A single (non-array) `marker.color`
+  paints the whole field one color.
+---
+var x = [];
+var y = [];
+var u = [];
+var v = [];
+var speed = [];
+
+// A shear flow: horizontal velocity grows with y, with a small vertical component.
+for (var i = 0; i <= 8; i++) {
+  for (var j = 0; j <= 6; j++) {
+    var ui = 0.2 + 0.25 * j;
+    var vi = 0.4 * Math.sin(i / 2);
+    x.push(i);
+    y.push(j);
+    u.push(ui);
+    v.push(vi);
+    speed.push(Math.sqrt(ui * ui + vi * vi));
+  }
+}
+
+var data = [{
+  type: 'quiver',
+  x: x,
+  y: y,
+  u: u,
+  v: v,
+  marker: {
+    color: speed,
+    colorscale: 'Viridis',
+    showscale: true,
+    colorbar: {title: {text: 'speed'}},
+    line: {width: 2}
+  }
+}];
+
+var layout = {
+  title: {text: 'Shear Flow, Arrows Colored by Speed'},
+  xaxis: {title: {text: 'x'}},
+  yaxis: {title: {text: 'y'}},
+  width: 700,
+  height: 500
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-style.html b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-style.html
new file mode 100644
index 000000000..72ef32ab8
--- /dev/null
+++ b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver-style.html
@@ -0,0 +1,66 @@
+---
+name: Style Arrow Lines and Heads
+language: plotly_js
+suite: quiver
+order: 4
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  `marker.line.width` and `marker.line.dash` style the arrow shafts, and `marker.arrowsize` scales the arrowhead
+  relative to the line width — the default of `1` draws a head about three times as wide as the shaft. This example
+  overlays a measured field (solid) on a modelled one (dashed) so the two can be compared arrow for arrow.
+---
+var x = [];
+var y = [];
+var uModel = [];
+var vModel = [];
+var uMeasured = [];
+var vMeasured = [];
+
+for (var i = 0; i <= 5; i++) {
+  for (var j = 0; j <= 5; j++) {
+    x.push(i);
+    y.push(j);
+    uModel.push(1);
+    vModel.push(0.15 * (j - 2.5));
+    uMeasured.push(0.9);
+    vMeasured.push(0.15 * (j - 2.5) + 0.25 * Math.cos(i));
+  }
+}
+
+var data = [{
+  type: 'quiver',
+  name: 'model',
+  x: x,
+  y: y,
+  u: uModel,
+  v: vModel,
+  marker: {
+    color: '#7f7f7f',
+    arrowsize: 0.8,
+    line: {width: 2, dash: 'dot'}
+  }
+}, {
+  type: 'quiver',
+  name: 'measured',
+  x: x,
+  y: y,
+  u: uMeasured,
+  v: vMeasured,
+  marker: {
+    color: '#d62728',
+    arrowsize: 1.2,
+    line: {width: 3}
+  }
+}];
+
+var layout = {
+  title: {text: 'Modelled and Measured Fields'},
+  xaxis: {title: {text: 'x'}},
+  yaxis: {title: {text: 'y'}},
+  showlegend: true,
+  width: 700,
+  height: 500
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/scientific/quiver/2026-08-04-quiver_plotly_js_index.html b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver_plotly_js_index.html
new file mode 100644
index 000000000..ed77e328d
--- /dev/null
+++ b/_posts/plotly_js/scientific/quiver/2026-08-04-quiver_plotly_js_index.html
@@ -0,0 +1,37 @@
+---
+description: How to make a D3.js-based quiver plot in JavaScript. Quiver plots show a 2D vector field as an array of arrows.
+display_as: scientific
+language: plotly_js
+layout: base
+name: Quiver Plots
+order: 13
+page_type: example_index
+permalink: javascript/quiver-plots/
+thumbnail: thumbnail/quiver-plot.jpg
+---
+
+<p>The <code>quiver</code> trace type, new in Plotly.js v4, visualizes a 2D vector field as an array of arrows. A
+quiver trace takes four arrays of the same length: <code>x</code> and <code>y</code> give the position of each arrow,
+and <code>u</code> and <code>v</code> give the vector components at that position. Arrow direction and length come
+from <code>(u, v)</code>.</p>
+
+<p>Arrow placement and scaling are controlled by:</p>
+
+<ul>
+  <li><code>anchor</code> — which part of the arrow sits at <code>(x, y)</code>: <code>'tail'</code> (the default),
+    <code>'tip'</code>, or <code>'center'</code>.</li>
+  <li><code>sizemode</code> — <code>'scaled'</code> (the default) normalizes arrow lengths against the largest vector
+    and the density of points, so a dense field stays readable; <code>'raw'</code> draws each arrow at its own
+    magnitude.</li>
+  <li><code>sizeref</code> — a multiplier applied on top of <code>sizemode</code>. Values below 1 shorten every
+    arrow, values above 1 lengthen them.</li>
+  <li><code>anglemode</code> — with <code>'data'</code>, angles are measured in data coordinates, so they change when
+    you zoom one axis more than the other; with <code>'paper'</code>, angles are fixed in pixel space.</li>
+</ul>
+
+<p>Arrow lines are styled with <code>marker.line.width</code> and <code>marker.line.dash</code>, and the arrowhead is
+scaled relative to the line width by <code>marker.arrowsize</code>. Quiver traces also support box and lasso
+selection through the standard <code>selected</code> / <code>unselected</code> marker attributes.</p>
+
+{% assign examples = site.posts | where:"language","plotly_js" | where:"suite","quiver" | sort: "order" %}
+{% include posts/auto_examples.html examples=examples %}
diff --git a/_posts/plotly_js/statistical/continuous-error-bars/2016-02-15-continuous-variable.html b/_posts/plotly_js/statistical/continuous-error-bars/2016-02-15-continuous-variable.html
index e8102ebca..e11b6b035 100644
--- a/_posts/plotly_js/statistical/continuous-error-bars/2016-02-15-continuous-variable.html
+++ b/_posts/plotly_js/statistical/continuous-error-bars/2016-02-15-continuous-variable.html
@@ -37,7 +37,7 @@
   x: date_list(2001,01,01,2001,02,01,50),
   y: random_number(50,20),
   line: {width: 0},
-  marker: {color: "444"},
+  marker: {color: "#444"},
   mode: "lines",
   name: "Lower Bound",
   type: "scatter"
@@ -60,7 +60,7 @@
   fill: "tonexty",
   fillcolor: "rgba(68, 68, 68, 0.3)",
   line: {width: 0},
-  marker: {color: "444"},
+  marker: {color: "#444"},
   mode: "lines",
   name: "Upper Bound",
   type: "scatter"
diff --git a/_posts/plotly_js/statistical/error-bar/2015-04-09-error-bar-style.html b/_posts/plotly_js/statistical/error-bar/2015-04-09-error-bar-style.html
index 0b76dfce6..55c14029d 100755
--- a/_posts/plotly_js/statistical/error-bar/2015-04-09-error-bar-style.html
+++ b/_posts/plotly_js/statistical/error-bar/2015-04-09-error-bar-style.html
@@ -46,4 +46,4 @@
   type: 'scatter'
 };
 var data = [trace1, trace2];
-Plotly.newPlot('myDiv', data, {}, {showSendToCloud: true});
+Plotly.newPlot('myDiv', data, {});
diff --git a/_posts/plotly_js/subplot/mixed-subplots/2017-01-20-mixed-subplots.html b/_posts/plotly_js/subplot/mixed-subplots/2017-01-20-mixed-subplots.html
index 442b32f5e..3fc235bfd 100644
--- a/_posts/plotly_js/subplot/mixed-subplots/2017-01-20-mixed-subplots.html
+++ b/_posts/plotly_js/subplot/mixed-subplots/2017-01-20-mixed-subplots.html
@@ -85,6 +85,7 @@
       y: [0.02, 0.98]
 		  },
         scope: 'world',
+        fitbounds: false,
         projection: {
           type: 'orthographic'
         },
@@ -140,6 +141,6 @@
       domain: [0.6, 1]},
 };
 
-Plotly.newPlot("myDiv", data, layout, {showLink: false});
+Plotly.newPlot("myDiv", data, layout);
 
 });
diff --git a/_posts/plotly_js/subplot/multiple-axes/2015-04-09-multiple-axes-double.html b/_posts/plotly_js/subplot/multiple-axes/2015-04-09-multiple-axes-double.html
index 8eed0bc93..f4a03159e 100755
--- a/_posts/plotly_js/subplot/multiple-axes/2015-04-09-multiple-axes-double.html
+++ b/_posts/plotly_js/subplot/multiple-axes/2015-04-09-multiple-axes-double.html
@@ -5,6 +5,10 @@
 order: 5
 sitemap: false
 arrangement: horizontal
+markdown_content: |
+  Set `overlaying` on the second axis to draw both traces in the same plotting area. The overlaying axis places its
+  ticks at the base axis's tick positions, labeled with its own range — see
+  [Tick Positions on Overlaying Axes](#tick-positions-on-overlaying-axes) to give it an independent grid instead.
 ---
 var trace1 = {
   x: [1, 2, 3],
diff --git a/_posts/plotly_js/subplot/multiple-axes/2026-08-04-overlaying-axis-tickmode.html b/_posts/plotly_js/subplot/multiple-axes/2026-08-04-overlaying-axis-tickmode.html
new file mode 100644
index 000000000..6956acc75
--- /dev/null
+++ b/_posts/plotly_js/subplot/multiple-axes/2026-08-04-overlaying-axis-tickmode.html
@@ -0,0 +1,53 @@
+---
+name: Tick Positions on Overlaying Axes
+language: plotly_js
+suite: multiple-axes
+order: 7
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  An axis that overlays another axis defaults to [tickmode](https://plotly.com/javascript/reference/layout/yaxis/#layout-yaxis-tickmode)
+  `'sync'`: it draws its ticks and gridlines at the base axis's positions and computes the labels from its own range, so
+  the two axes share one grid. Set `tickmode: 'auto'` on the overlaying axis to let it choose its own tick positions
+  instead, which draws a second, independent set of gridlines.
+
+  Prior to Plotly.js v4, `'auto'` was the default on overlaying axes. When the base axis is `type: 'category'` or
+  `'multicategory'`, `'auto'` is still the default.
+---
+var trace1 = {
+  x: [1, 2, 3],
+  y: [40, 50, 60],
+  name: 'yaxis data',
+  type: 'scatter'
+};
+
+var trace2 = {
+  x: [2, 3, 4],
+  y: [4, 5, 6],
+  name: 'yaxis2 data',
+  yaxis: 'y2',
+  type: 'scatter'
+};
+
+var data = [trace1, trace2];
+
+var layout = {
+  title: {text: 'Independent Ticks on an Overlaying Axis'},
+  yaxis: {
+    title: {
+      text: 'yaxis title'
+    }
+  },
+  yaxis2: {
+    title: {
+      text: 'yaxis2 title',
+      font: {color: 'rgb(148, 103, 189)'}
+    },
+    tickfont: {color: 'rgb(148, 103, 189)'},
+    overlaying: 'y',
+    side: 'right',
+    tickmode: 'auto'
+  }
+};
+
+Plotly.newPlot('myDiv', data, layout);

From 16fd8d0827f87ac455be0f374964bac9c8c2c6dd Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 5 Aug 2026 16:43:32 -0600
Subject: [PATCH 19/25] Remove Mapbox references

---
 .github/workflows/build.yml                   |  5 --
 _includes/posts/auto_examples.html            |  6 +--
 .../2015-09-24-config-opt-link-text.html      | 27 -----------
 .../2015-09-24-config-opt-showlink.html       | 32 -------------
 .../2019-07-03-outline-map-locations.html     |  2 +-
 ...2015-07-11-bubble_maps_plotlyjs_index.html |  2 +-
 ...2019-08-16-choropleth_plotly_js_index.html |  2 +-
 .../2024-06-29-basic-mapbox.html              | 27 -----------
 ...2015-07-11-choropleth_plotly_js_index.html |  2 +-
 .../2019-08-16-basic_density_mapbox.html      | 20 ++++++--
 .../2019-08-16-density_plotly_js_index.html   |  2 +-
 .../2019-08-16-light-tile-mapbox.html         | 27 -----------
 .../2019-09-02-fill-area_plotly_js_index.html |  2 +-
 ...5-07-11-lines_on_maps_plotly_js_index.html |  2 +-
 .../2026-08-04-map-view_plotly_js_index.html  |  2 +-
 .../2019-08-16-access-token.html              | 29 ------------
 .../2019-08-16-how-layers-work.html           | 12 +++++
 ...9-08-20-mapbox-layers_plotly_js_index.html |  2 +-
 ...9-migrate-to-maplibre_plotly_js_index.html |  2 +-
 ...15-07-11-scatter_maps_plotly_js_index.html |  2 +-
 ...2017-08-01-scattermapbox_basic-mapbox.html | 46 -------------------
 ...7-08-01-scattermapbox_plotly_js_index.html |  2 +-
 22 files changed, 44 insertions(+), 211 deletions(-)
 delete mode 100644 _posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-link-text.html
 delete mode 100644 _posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-showlink.html
 delete mode 100644 _posts/plotly_js/maps/choropleth-mapbox/2024-06-29-basic-mapbox.html
 delete mode 100755 _posts/plotly_js/maps/density-mapbox/2019-08-16-light-tile-mapbox.html
 delete mode 100644 _posts/plotly_js/maps/mapbox-layers/2019-08-16-access-token.html
 delete mode 100644 _posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_basic-mapbox.html

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 9a9f326b3..868763a97 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -33,10 +33,6 @@ jobs:
       - name: Fetch upstream docs
         run: make fetch_upstream_files
 
-      - name: Set up Mapbox token
-        run: |
-          echo "token: ${{ secrets.MAPBOX_TOKEN }}" > _data/mapbox_token.yml
-
       - name: Build site
         run: |
           python front-matter-ci.py _posts
@@ -49,7 +45,6 @@ jobs:
           md5sum all_static/css/main.css | cut -d ' ' -f 1 > _data/cache_bust_css.yml
           bundle exec jekyll build
           cp python/sitemap.xml _site/python/sitemap.xml
-          rm _data/mapbox_token.yml
 
       - name: Create Percy snapshots
         run: |
diff --git a/_includes/posts/auto_examples.html b/_includes/posts/auto_examples.html
index 8c1192cd4..00540f9c4 100755
--- a/_includes/posts/auto_examples.html
+++ b/_includes/posts/auto_examples.html
@@ -41,8 +41,8 @@ <h3 id="{{ example.name | replace:' ','-' | remove:',' | downcase | strip_html }
               {% assign d3 = "" %}
             {% endif %}
 
-            {% if example.content contains "remember to load MathJax.js" %}
-              {% assign mathjax = "\n\t&lt;script src='//cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML'>&lt;/script&gt;" %}
+            {% if example.content contains "remember to load MathJax" %}
+              {% assign mathjax = "\n\t&lt;script src='https://cdn.jsdelivr.net/npm/mathjax@3.2.2/es5/tex-svg.js'>&lt;/script&gt;" %}
             {% else %}
               {% assign mathjax = "" %}
             {% endif %}
@@ -55,7 +55,7 @@ <h3 id="{{ example.name | replace:' ','-' | remove:',' | downcase | strip_html }
               {% capture unique_myDiv %}myDiv_{{counter}}{% endcapture %}
               <div style="max-width: 100%; margin: auto" id="{{unique_myDiv}}"></div>
               <script>
-                {{ example.content | replace: 'myDiv', unique_myDiv | replace: "your access token", site.data.mapbox_token['token']}}
+                {{ example.content | replace: 'myDiv', unique_myDiv }}
               </script>
             </div>
           {% endif %}
diff --git a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-link-text.html b/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-link-text.html
deleted file mode 100644
index e3f409e76..000000000
--- a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-link-text.html
+++ /dev/null
@@ -1,27 +0,0 @@
----
-name: Customize The `Edit Chart` Link Text
-language: plotly_js
-suite: configuration
-order: 7
-sitemap: false
-arrangement: horizontal
----
-var data = [{
-  z: [[0, 1, 2, 3, 4, 5, 6],
-      [1, 9, 4, 7, 5, 2, 4],
-      [2, 4, 2, 1, 6, 9, 3]],
-  type: 'heatmap'}]
-
-var layout = {
-  title: {
-      text: 'Customize The Edit Chart Link Text'
-  }
-};
-
-var config = {
-  showLink: true,
-  plotlyServerURL: "https://chart-studio.plotly.com",
-  linkText: 'This text is custom!'
-};
-
-Plotly.newPlot('myDiv', data, layout, config)
diff --git a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-showlink.html b/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-showlink.html
deleted file mode 100644
index b75ab5859..000000000
--- a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-opt-showlink.html
+++ /dev/null
@@ -1,32 +0,0 @@
----
-name: Display the `Edit Chart` Link
-language: plotly_js
-suite: configuration
-order: 6
-sitemap: false
-arrangement: horizontal
-markdown_content: |
-  Note: <code>showLink</code> now defaults to false.
----
-
-var trace1 = {
-  x: [0, 1, 2, 3, 4, 5, 6],
-  y: [1, 9, 4, 7, 5, 2, 4],
-  mode: 'lines+markers',
-  type: 'scatter'
-};
-
-var data = [trace1];
-
-var layout = {
-  title: {
-      text: 'Display the Edit Chart Link'
-  }
-};
-
-var config = {
-  showLink: true,
-  plotlyServerURL: "https://chart-studio.plotly.com"
-};
-
-Plotly.newPlot('myDiv', data, layout, config);
diff --git a/_posts/plotly_js/maps/2019-07-03-outline-map-locations.html b/_posts/plotly_js/maps/2019-07-03-outline-map-locations.html
index 6da1cfee7..ba206c630 100644
--- a/_posts/plotly_js/maps/2019-07-03-outline-map-locations.html
+++ b/_posts/plotly_js/maps/2019-07-03-outline-map-locations.html
@@ -4,7 +4,7 @@
 language: plotly_js
 layout: base
 name: Locations for Outline-based Maps
-order: 11
+order: 10
 page_type: example_index
 permalink: javascript/outline-map-locations/
 thumbnail: thumbnail/choropleth.jpg
diff --git a/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble_maps_plotlyjs_index.html b/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble_maps_plotlyjs_index.html
index 2effd4079..a0c1b669d 100755
--- a/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble_maps_plotlyjs_index.html
+++ b/_posts/plotly_js/maps/bubble-maps/2015-07-11-bubble_maps_plotlyjs_index.html
@@ -5,7 +5,7 @@
 language: plotly_js
 layout: base
 name: Bubble Maps
-order: 6
+order: 5
 page_type: example_index
 permalink: javascript/bubble-maps/
 redirect_from: javascript-graphing-library/bubble-maps/
diff --git a/_posts/plotly_js/maps/choropleth-mapbox/2019-08-16-choropleth_plotly_js_index.html b/_posts/plotly_js/maps/choropleth-mapbox/2019-08-16-choropleth_plotly_js_index.html
index e759a0652..96df0f823 100644
--- a/_posts/plotly_js/maps/choropleth-mapbox/2019-08-16-choropleth_plotly_js_index.html
+++ b/_posts/plotly_js/maps/choropleth-mapbox/2019-08-16-choropleth_plotly_js_index.html
@@ -4,7 +4,7 @@
 language: plotly_js
 layout: base
 name: Choropleth Tile Map
-order: 4
+order: 3
 page_type: example_index
 permalink: javascript/tile-county-choropleth/
 redirect_from: javascript/mapbox-county-choropleth/
diff --git a/_posts/plotly_js/maps/choropleth-mapbox/2024-06-29-basic-mapbox.html b/_posts/plotly_js/maps/choropleth-mapbox/2024-06-29-basic-mapbox.html
deleted file mode 100644
index 0df34d165..000000000
--- a/_posts/plotly_js/maps/choropleth-mapbox/2024-06-29-basic-mapbox.html
+++ /dev/null
@@ -1,27 +0,0 @@
----
-name: Basic Tile using Mapbox
-language: plotly_js
-suite: tile-county-choropleth
-order: 4
-sitemap: false
-arrangement: horizontal
-markdown_content: |
-
-    <strong>> Mapbox traces are deprecated and may be removed in a future version of Plotly.js.</strong>
-
-    Earlier examples use traces that render with [Maplibre GL JS](https://maplibre.org/maplibre-gl-js/docs/).
-    These traces were introduced in Plotly.js 2.35.0 and replace Mapbox-based tile maps,
-    which are now deprecated. Here's one of the earlier examples using the Mapbox-based `choroplethmapbox` trace
----
-
-var data = [{
-  type: "choroplethmapbox", locations: ["NY", "MA", "VT"], z: [-50, -10, -20],
-  geojson: "https://raw.githubusercontent.com/python-visualization/folium/master/examples/data/us-states.json"
-}];
-
-var layout = {mapbox: {center: {lon: -74, lat: 43}, zoom: 3.5},
-              width: 600, height:400};
-
-var config = {mapboxAccessToken: "your access token"};
-
-Plotly.newPlot('myDiv', data, layout, config);
\ No newline at end of file
diff --git a/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth_plotly_js_index.html b/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth_plotly_js_index.html
index 60cce827f..f8aeed399 100755
--- a/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth_plotly_js_index.html
+++ b/_posts/plotly_js/maps/choropleth-maps/2015-07-11-choropleth_plotly_js_index.html
@@ -5,7 +5,7 @@
 language: plotly_js
 layout: base
 name: Choropleth Maps
-order: 9
+order: 8
 permalink: javascript/choropleth-maps/
 redirect_from: javascript-graphing-library/choropleth-maps/
 thumbnail: thumbnail/choropleth.jpg
diff --git a/_posts/plotly_js/maps/density-mapbox/2019-08-16-basic_density_mapbox.html b/_posts/plotly_js/maps/density-mapbox/2019-08-16-basic_density_mapbox.html
index 6c168a371..4881cf80e 100755
--- a/_posts/plotly_js/maps/density-mapbox/2019-08-16-basic_density_mapbox.html
+++ b/_posts/plotly_js/maps/density-mapbox/2019-08-16-basic_density_mapbox.html
@@ -1,5 +1,5 @@
 ---
-name: Stamen Terrain Tile
+name: Custom Tile Style
 language: plotly_js
 suite: tile-density-heatmaps
 order: 5
@@ -8,10 +8,24 @@
 arrangement: horizontal
 markdown_content: |
 
+  As well as the built-in style names, `layout.map.style` accepts the URL of any
+  [MapLibre style definition](https://maplibre.org/maplibre-style-spec/). The example below points at Carto's Positron
+  style JSON directly.
 
+  Some providers require an API key, which you append to the style URL. The `stamen-terrain`, `stamen-toner`, and
+  `stamen-watercolor` style names are not built in for this reason: Stamen tiles are served by
+  [Stadia Maps](https://stadiamaps.com/), which requires an account. To use them, sign up and add your own key:
+
+  ```
+  map: {style: 'https://tiles.stadiamaps.com/styles/stamen_watercolor.json?api_key=YOUR_STADIA_KEY'}
+  ```
 ---
-var data = [{type: 'densitymapbox', lon: [10, 20, 30], lat: [15, 25, 35], z: [1, 3, 2]}];
+var data = [{type: 'densitymap', lon: [10, 20, 30], lat: [15, 25, 35], z: [1, 3, 2]}];
 
-var layout = {width: 600, height: 400, mapbox: {style: 'https://tiles.stadiamaps.com/styles/stamen_watercolor.json?api_key=YOUR-API-KEY'}};
+var layout = {
+  width: 600,
+  height: 400,
+  map: {style: 'https://basemaps.cartocdn.com/gl/positron-gl-style/style.json'}
+};
 
 Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/maps/density-mapbox/2019-08-16-density_plotly_js_index.html b/_posts/plotly_js/maps/density-mapbox/2019-08-16-density_plotly_js_index.html
index 7bc025f88..4b6921182 100755
--- a/_posts/plotly_js/maps/density-mapbox/2019-08-16-density_plotly_js_index.html
+++ b/_posts/plotly_js/maps/density-mapbox/2019-08-16-density_plotly_js_index.html
@@ -5,7 +5,7 @@
 language: plotly_js
 layout: base
 name: Tile Density Heatmap
-order: 3
+order: 2
 page_type: example_index
 permalink: javascript/tile-density-heatmaps/
 redirect_from: javascript/mapbox-density-heatmaps/
diff --git a/_posts/plotly_js/maps/density-mapbox/2019-08-16-light-tile-mapbox.html b/_posts/plotly_js/maps/density-mapbox/2019-08-16-light-tile-mapbox.html
deleted file mode 100755
index ed0cd3576..000000000
--- a/_posts/plotly_js/maps/density-mapbox/2019-08-16-light-tile-mapbox.html
+++ /dev/null
@@ -1,27 +0,0 @@
----
-name: Light Tile (Mapbox) - Requires Token
-language: plotly_js
-layout: base
-suite: tile-density-heatmaps
-order: 7
-sitemap: false
-arrangement: horizontal
-markdown_content: |
-  **Mapbox traces are deprecated and may be removed in a future version of Plotly.js.**
-
-  Earlier examples use traces that render with [Maplibre GL JS](https://maplibre.org/maplibre-gl-js/docs/).
-  These traces were introduced in Plotly.js 2.35.0 and replace Mapbox-based tile maps,
-  which are now deprecated. Here's one of the earlier examples written using the Mapbox-based `densitymapbox` trace.
----
-var data = [
-  {type: "densitymapbox", lon: [10, 20, 30], lat: [15, 25, 35], z: [1, 3, 2],
-   radius: 50, colorbar: {y: 1, yanchor: 'top', len: 0.45}},
-  {type: 'densitymapbox', lon: [-10, -20, -30], lat: [15, 25, 35],
-   radius: [50, 100, 10],  colorbar: {y: 0, yanchor: 'bottom', len: 0.45}
-  }];
-
-var layout = {mapbox: {style: 'light', center: {lat: 20}}, width: 600, height: 400};
-
-var config = {mapboxAccessToken: "your access token"};
-
-Plotly.newPlot('myDiv', data, layout, config);
diff --git a/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-fill-area_plotly_js_index.html b/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-fill-area_plotly_js_index.html
index 2f563f4bf..1a98cefc7 100644
--- a/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-fill-area_plotly_js_index.html
+++ b/_posts/plotly_js/maps/fill-area-on-mapbox/2019-09-02-fill-area_plotly_js_index.html
@@ -5,7 +5,7 @@
 language: plotly_js
 layout: base
 name: Filled Area on Tile Maps
-order: 10
+order: 9
 page_type: u-guide
 permalink: javascript/filled-area-on-map/
 redirect_from: javascript/filled-area-on-mapbox/
diff --git a/_posts/plotly_js/maps/lines-on-maps/2015-07-11-lines_on_maps_plotly_js_index.html b/_posts/plotly_js/maps/lines-on-maps/2015-07-11-lines_on_maps_plotly_js_index.html
index b22ea5ada..d758b1651 100755
--- a/_posts/plotly_js/maps/lines-on-maps/2015-07-11-lines_on_maps_plotly_js_index.html
+++ b/_posts/plotly_js/maps/lines-on-maps/2015-07-11-lines_on_maps_plotly_js_index.html
@@ -6,7 +6,7 @@
 language: plotly_js
 layout: base
 name: Lines on Maps
-order: 5
+order: 4
 page_type: example_index
 permalink: javascript/lines-on-maps/
 redirect_from: javascript-graphing-library/lines-on-maps/
diff --git a/_posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html b/_posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html
index 388805a1b..700920a6c 100644
--- a/_posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html
+++ b/_posts/plotly_js/maps/map-view/2026-08-04-map-view_plotly_js_index.html
@@ -4,7 +4,7 @@
 language: plotly_js
 layout: base
 name: Map View and Zoom
-order: 12
+order: 11
 page_type: example_index
 permalink: javascript/map-view/
 thumbnail: thumbnail/county-level-choropleth.jpg
diff --git a/_posts/plotly_js/maps/mapbox-layers/2019-08-16-access-token.html b/_posts/plotly_js/maps/mapbox-layers/2019-08-16-access-token.html
deleted file mode 100644
index aa232bf04..000000000
--- a/_posts/plotly_js/maps/mapbox-layers/2019-08-16-access-token.html
+++ /dev/null
@@ -1,29 +0,0 @@
----
-name: Mapbox Maps and Access Tokens
-language: plotly_js
-suite: map-layers
-order: 10
-sitemap: false
-arrangement: horizontal
-markdown_content: |
-
-    <strong>> Mapbox traces are deprecated and may be removed in a future version of Plotly.js.</strong>
-
-    The word "mapbox" in the trace names and `layout.mapbox` refers to the Mapbox GL JS open-source library.
-    If your basemap in `layout.mapbox.style` uses data from the Mapbox *service*,
-    then you will need to register for a free account at https://mapbox.com/ and obtain a Mapbox Access token.
-    If your basemap uses data from the [Stadia Maps service](https://www.stadiamaps.com) (see below for details), you'll need to register for a Stadia Maps account and token.
-
-    To use a token, provide it as `mapboxAccessToken` in the `setPlotConfig` function, or as a variable that would be passed as an argument of `newPlot`.
-    If your `layout.mapbox.style` does not use data from the Mapbox service, you do *not* need to register for a Mapbox account.
-    <h6>Base Maps in `layout.mapbox.style`</h6>
-    The accepted values for `layout.mapbox.style` are one of the following tiles.
-    <ol>
-        <li> `"white-bg"` yields an empty white canvas which results in no external HTTP requests </li>
-        <li> `"open-street-map"`, `"carto-positron"`, or `"carto-darkmatter"` yield maps composed of *raster* tiles from various public tile servers which do not require signups or access tokens </li>
-        <li> `"stamen-terrain"`, `"stamen-toner"` or `"stamen-watercolor"` yield maps composed of *raster* tiles from the [Stadia Maps service](https://stadiamaps.com/) and require a Stadia Maps account and token.</li>
-        <li> `"basic"`, `"streets"`, `"outdoors"`, `"light"`, `"dark"`, `"satellite"`, or `"satellite-streets"` yield maps composed of *vector* tiles from the Mapbox service, and *do* require a Mapbox Access Token or an on-premise Mapbox installation. </li>
-        <li> A Mapbox service style URL, which requires a Mapbox Access Token or an on-premise Mapbox installation. </li>
-        <li> A Mapbox Style object as defined at https://docs.mapbox.com/mapbox-gl-js/style-spec/ </li>
-    </ol>
----
diff --git a/_posts/plotly_js/maps/mapbox-layers/2019-08-16-how-layers-work.html b/_posts/plotly_js/maps/mapbox-layers/2019-08-16-how-layers-work.html
index 4c533908b..50c3a3e3a 100644
--- a/_posts/plotly_js/maps/mapbox-layers/2019-08-16-how-layers-work.html
+++ b/_posts/plotly_js/maps/mapbox-layers/2019-08-16-how-layers-work.html
@@ -14,4 +14,16 @@
         <li> `layout.map.layers` is an array that defines more layers that are by default rendered above the traces in `data` (although this can also be controlled via the `below` attribute).</li>
     </ol>
 
+    <h6>Base maps in `layout.map.style`</h6>
+
+    None of the built-in base maps require an account or an access token. The accepted values are:
+    <ol>
+        <li> `"white-bg"` yields an empty white canvas, which makes no external HTTP requests</li>
+        <li> `"open-street-map"` yields raster tiles from [OpenStreetMap](https://www.openstreetmap.org)</li>
+        <li> `"basic"`, `"streets"`, `"outdoors"`, `"light"`, `"dark"`, `"satellite"`, and `"satellite-streets"` yield vector tiles from [Carto](https://github.com/cartodb/basemap-styles/) and [ArcGIS](https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer)</li>
+        <li> `"carto-positron"`, `"carto-darkmatter"`, `"carto-voyager"`, and their `-nolabels` variants yield the corresponding [Carto](https://github.com/cartodb/basemap-styles/) tiles</li>
+        <li> The URL of a [MapLibre style definition](https://maplibre.org/maplibre-style-spec/), for any other provider. Some providers require an API key, which you append to the style URL — Stamen tiles, for example, are served by [Stadia Maps](https://stadiamaps.com/) and need a Stadia account</li>
+        <li> A Map Style object, of the form described in the [MapLibre GL JS documentation](https://maplibre.org/maplibre-style-spec/)</li>
+    </ol>
+
 ---
diff --git a/_posts/plotly_js/maps/mapbox-layers/2019-08-20-mapbox-layers_plotly_js_index.html b/_posts/plotly_js/maps/mapbox-layers/2019-08-20-mapbox-layers_plotly_js_index.html
index 3e36160d2..32c4584f9 100644
--- a/_posts/plotly_js/maps/mapbox-layers/2019-08-20-mapbox-layers_plotly_js_index.html
+++ b/_posts/plotly_js/maps/mapbox-layers/2019-08-20-mapbox-layers_plotly_js_index.html
@@ -4,7 +4,7 @@
 language: plotly_js
 layout: base
 name: Tile Map Layers
-order: 2
+order: 1
 page_type: example_index
 permalink: javascript/tile-map-layers/
 redirect_from: javascript/mapbox-layers/
diff --git a/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html b/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html
index e26c2d6ca..30b42fe36 100644
--- a/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html
+++ b/_posts/plotly_js/maps/maplibre-migration/2024-08-29-migrate-to-maplibre_plotly_js_index.html
@@ -4,7 +4,7 @@
 language: plotly_js
 layout: base
 name: Migrate to Maplibre
-order: 1
+order: 12
 page_type: example_index
 permalink: javascript/maplibre-migration/
 thumbnail: thumbnail/area.jpg
diff --git a/_posts/plotly_js/maps/scatter-plot-on-maps/2015-07-11-scatter_maps_plotly_js_index.html b/_posts/plotly_js/maps/scatter-plot-on-maps/2015-07-11-scatter_maps_plotly_js_index.html
index a15592334..4447dfa7c 100755
--- a/_posts/plotly_js/maps/scatter-plot-on-maps/2015-07-11-scatter_maps_plotly_js_index.html
+++ b/_posts/plotly_js/maps/scatter-plot-on-maps/2015-07-11-scatter_maps_plotly_js_index.html
@@ -5,7 +5,7 @@
 language: plotly_js
 layout: base
 name: Scatter Plots on Maps
-order: 7
+order: 6
 permalink: javascript/scatter-plots-on-maps/
 redirect_from: javascript-graphing-library/scatter-plots-on-maps/
 thumbnail: thumbnail/scatter-plot-on-maps.jpg
diff --git a/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_basic-mapbox.html b/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_basic-mapbox.html
deleted file mode 100644
index b8c3d7243..000000000
--- a/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_basic-mapbox.html
+++ /dev/null
@@ -1,46 +0,0 @@
----
-name: Basic Example (Mapbox)
-language: plotly_js
-suite: scatter-tile-maps
-order: 10
-sitemap: false
-arrangement: horizontal
-markdown_content: |
-
-  <strong>> Mapbox traces are deprecated and may be removed in a future version of Plotly.js.</strong>
-
-    Earlier examples use traces that render with [Maplibre GL JS](https://maplibre.org/maplibre-gl-js/docs/).
-    These traces were introduced in Plotly.js 2.35.0 and replace Mapbox-based tile maps,
-    which are now deprecated. Here's one of the earlier examples using the Mapbox-based `choroplethmapbox` trace
----
-
-var data = [{
-  type:'scattermapbox',
-  lat:['45.5017'],
-  lon:['-73.5673'],
-  mode:'markers',
-  marker: {
-    size:14
-  },
-  text:['Montreal']
-}]
-
-var layout = {
-  autosize: true,
-  hovermode:'closest',
-  mapbox: {
-    bearing:0,
-    center: {
-      lat:45,
-      lon:-73
-    },
-    pitch:0,
-    zoom:5
-  },
-}
-
-Plotly.setPlotConfig({
-  mapboxAccessToken: "your access token"
-})
-
-Plotly.newPlot('myDiv', data, layout)
diff --git a/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_plotly_js_index.html b/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_plotly_js_index.html
index efef2c956..9df66d355 100755
--- a/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_plotly_js_index.html
+++ b/_posts/plotly_js/maps/scattermapbox/2017-08-01-scattermapbox_plotly_js_index.html
@@ -4,7 +4,7 @@
 language: plotly_js
 layout: base
 name: Scatter Plots on Tile Maps
-order: 8
+order: 7
 permalink: javascript/scatter-tile-maps/
 redirect_from: javascript/scattermapbox/
 thumbnail: thumbnail/scatter-mapbox.jpg

From 511e7b4760bf9d4508f17d7e8538c046f66cb876 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Wed, 5 Aug 2026 17:02:43 -0600
Subject: [PATCH 20/25] Update Sankey pages

---
 .../basic/sankey/2017-05-22-add_nodes.html    | 50 -------------------
 .../basic/sankey/2017-05-22-basic.html        | 33 ------------
 .../2017-05-22-sankey-from-dataset.html       | 14 +++---
 .../basic/sankey/2017-05-22-sankey_index.html |  2 +-
 .../basic/sankey/2017-05-22-style_sankey.html |  8 +--
 .../sankey/2018-03-13-basic-example.html      |  6 +--
 .../sankey/2019-11-20-nodes-position.html     |  2 +-
 .../sankey/2024-01-05-align-example.html      | 10 ++--
 .../sankey/2026-08-04-sankey-direction.html   | 38 ++++++++++++++
 .../basic/sankey/2026-08-04-sankey-sort.html  | 40 +++++++++++++++
 10 files changed, 101 insertions(+), 102 deletions(-)
 delete mode 100644 _posts/plotly_js/basic/sankey/2017-05-22-add_nodes.html
 delete mode 100644 _posts/plotly_js/basic/sankey/2017-05-22-basic.html
 create mode 100644 _posts/plotly_js/basic/sankey/2026-08-04-sankey-direction.html
 create mode 100644 _posts/plotly_js/basic/sankey/2026-08-04-sankey-sort.html

diff --git a/_posts/plotly_js/basic/sankey/2017-05-22-add_nodes.html b/_posts/plotly_js/basic/sankey/2017-05-22-add_nodes.html
deleted file mode 100644
index 2f88e09df..000000000
--- a/_posts/plotly_js/basic/sankey/2017-05-22-add_nodes.html
+++ /dev/null
@@ -1,50 +0,0 @@
----
-name: Add Nodes
-language: plotly_js
-suite: sankey
-order: 3
-sitemap: false
-arrangement: horizontal
-description:
----
-
-d3.json('https://raw.githubusercontent.com/plotly/plotly.js/master/test/image/mocks/sankey_energy.json', function(fig){
-
-var data = {
-  type: "sankey",
-  domain: {
-    x: [0,1],
-    y: [0,1]
-  },
-  orientation: "h",
-  valueformat: ".0f",
-  valuesuffix: "TWh",
-
-  node: {
-    pad: 15,
-    thickness: 15,
-    line: {
-      color: "black",
-      width: 0.5
-    },
-   label: fig.data[0].node.label,
-   color: fig.data[0].node.color
-      }
-}
-
-var data = [data]
-
-var layout = {
-  title: {
-    text: "Energy forecast for 2050<br>Source: Department of Energy & Climate Change, Tom Counsell via <a href='https://bost.ocks.org/mike/sankey/'>Mike Bostock</a>"
-  },
-  width: 1118,
-  height: 772,
-  font: {
-    size: 10
-  }
-}
-
-Plotly.newPlot('myDiv', data, layout)
-
-});
diff --git a/_posts/plotly_js/basic/sankey/2017-05-22-basic.html b/_posts/plotly_js/basic/sankey/2017-05-22-basic.html
deleted file mode 100644
index 25c79ff00..000000000
--- a/_posts/plotly_js/basic/sankey/2017-05-22-basic.html
+++ /dev/null
@@ -1,33 +0,0 @@
----
-name: Create Sankey Canvas
-language: plotly_js
-suite: sankey
-order: 2
-sitemap: false
-arrangement: horizontal
-description:
----
-
-var data = {
-  type: "sankey",
-  domain: {
-    x: [0,1],
-    y: [0,1]
-  },
-  orientation: "h",
-  valueformat: ".0f",
-  valuesuffix: "TWh"
-}
-
-var data = [data]
-
-var layout = {
-  title: {
-    text: "Energy forecast for 2050<br>Source: Department of Energy & Climate Change, Tom Counsell via <a href='https://bost.ocks.org/mike/sankey/'>Mike Bostock</a>"
-  },
-  width: 1118,
-  height: 772,
-  font: {
-    size: 10
-  }
-}
diff --git a/_posts/plotly_js/basic/sankey/2017-05-22-sankey-from-dataset.html b/_posts/plotly_js/basic/sankey/2017-05-22-sankey-from-dataset.html
index e602514e1..e6b106d3f 100644
--- a/_posts/plotly_js/basic/sankey/2017-05-22-sankey-from-dataset.html
+++ b/_posts/plotly_js/basic/sankey/2017-05-22-sankey-from-dataset.html
@@ -1,16 +1,18 @@
 ---
-name: Add Links
+name: Sankey Diagram from a Dataset
 language: plotly_js
 suite: sankey
-order: 4
+order: 2
 sitemap: false
 arrangement: horizontal
-description:
+markdown_content: |
+  A sankey trace is defined by its `link` arrays — `source` and `target` hold indices into `node.label`, and `value`
+  sets the width of each flow. Node positions and heights are derived from the links attached to them.
 ---
 
 d3.json('https://raw.githubusercontent.com/plotly/plotly.js/master/test/image/mocks/sankey_energy.json', function(fig){
 
-var data = {
+var trace = {
   type: "sankey",
   domain: {
     x: [0,1],
@@ -38,13 +40,13 @@
   }
 }
 
-var data = [data]
+var data = [trace]
 
 var layout = {
   title: {
     text: "Energy forecast for 2050<br>Source: Department of Energy & Climate Change, Tom Counsell via <a href='https://bost.ocks.org/mike/sankey/'>Mike Bostock</a>"
   },
-  width: 1118,
+  width: 950,
   height: 772,
   font: {
     size: 10
diff --git a/_posts/plotly_js/basic/sankey/2017-05-22-sankey_index.html b/_posts/plotly_js/basic/sankey/2017-05-22-sankey_index.html
index b39b8a322..a453e30d3 100755
--- a/_posts/plotly_js/basic/sankey/2017-05-22-sankey_index.html
+++ b/_posts/plotly_js/basic/sankey/2017-05-22-sankey_index.html
@@ -10,4 +10,4 @@
 ---
 
 {% assign examples = site.posts | where:"language","plotly_js" | where:"suite","sankey" | sort: "order" %}
-{% include posts/auto_examples.html examples=examples %}
\ No newline at end of file
+{% include posts/auto_examples.html examples=examples %}
diff --git a/_posts/plotly_js/basic/sankey/2017-05-22-style_sankey.html b/_posts/plotly_js/basic/sankey/2017-05-22-style_sankey.html
index eaf7e3fd7..78a27b0e5 100644
--- a/_posts/plotly_js/basic/sankey/2017-05-22-style_sankey.html
+++ b/_posts/plotly_js/basic/sankey/2017-05-22-style_sankey.html
@@ -2,7 +2,7 @@
 name: Style Sankey Diagram
 language: plotly_js
 suite: sankey
-order: 5
+order: 3
 sitemap: false
 arrangement: horizontal
 description:
@@ -10,7 +10,7 @@
 
 d3.json('https://raw.githubusercontent.com/plotly/plotly.js/master/test/image/mocks/sankey_energy_dark.json', function(fig){
 
-var data = {
+var trace = {
   type: "sankey",
   domain: {
     x: [0,1],
@@ -37,13 +37,13 @@
   }
 }
 
-var data = [data]
+var data = [trace]
 
 var layout = {
   title: {
     text: "Energy forecast for 2050<br>Source: Department of Energy & Climate Change, Tom Counsell via <a href='https://bost.ocks.org/mike/sankey/'>Mike Bostock</a>"
   },
-  width: 1118,
+  width: 950,
   height: 772,
   font: {
     size: 10,
diff --git a/_posts/plotly_js/basic/sankey/2018-03-13-basic-example.html b/_posts/plotly_js/basic/sankey/2018-03-13-basic-example.html
index 85bce2638..bc4523f9a 100644
--- a/_posts/plotly_js/basic/sankey/2018-03-13-basic-example.html
+++ b/_posts/plotly_js/basic/sankey/2018-03-13-basic-example.html
@@ -8,7 +8,7 @@
 description:
 ---
 
-var data = {
+var trace = {
   type: "sankey",
   orientation: "h",
   node: {
@@ -29,7 +29,7 @@
   }
 }
 
-var data = [data]
+var data = [trace]
 
 var layout = {
   title: {
@@ -40,4 +40,4 @@
   }
 }
 
-Plotly.react('myDiv', data, layout)
+Plotly.newPlot('myDiv', data, layout)
diff --git a/_posts/plotly_js/basic/sankey/2019-11-20-nodes-position.html b/_posts/plotly_js/basic/sankey/2019-11-20-nodes-position.html
index 15f4544f2..a273c079d 100644
--- a/_posts/plotly_js/basic/sankey/2019-11-20-nodes-position.html
+++ b/_posts/plotly_js/basic/sankey/2019-11-20-nodes-position.html
@@ -2,7 +2,7 @@
 name: Define Node Position
 language: plotly_js
 suite: sankey
-order: 6
+order: 4
 sitemap: false
 arrangement: horizontal
 description:
diff --git a/_posts/plotly_js/basic/sankey/2024-01-05-align-example.html b/_posts/plotly_js/basic/sankey/2024-01-05-align-example.html
index 2dd8c887e..7434c9351 100644
--- a/_posts/plotly_js/basic/sankey/2024-01-05-align-example.html
+++ b/_posts/plotly_js/basic/sankey/2024-01-05-align-example.html
@@ -2,14 +2,16 @@
 name: Node Alignment
 language: plotly_js
 suite: sankey
-order: 7
+order: 5
 sitemap: false
 arrangement: horizontal
 markdown_content : |
-  You can set the alignment of nodes using `node.align`. In this example, we align nodes to the "right". `node.align` can also be set to "left", "center", or "justify". The default is "justify" if ``node.align` is not set, and is similar to aligning to the "left", except that nodes without outgoing links are moved to the right of the figure.
+  You can set the alignment of nodes using `node.align`. In this example, we align nodes to the "right". `node.align` can also be set to "left", "center", or "justify". The default is "justify" if `node.align` is not set, and is similar to aligning to the "left", except that nodes without outgoing links are moved to the right of the figure.
+
+  `node.align` only decides which column a node is placed in, for nodes whose position isn't already pinned by the links attached to them. It does not change which end of the diagram the sources sit on — for that, see [Flow Direction](#flow-direction).
 ---
 
-var data = {
+var trace = {
   type: "sankey",
   orientation: "h",
   node: {
@@ -24,7 +26,7 @@
   },
 };
 
-var data = [data];
+var data = [trace];
 
 var layout = {
   title: {
diff --git a/_posts/plotly_js/basic/sankey/2026-08-04-sankey-direction.html b/_posts/plotly_js/basic/sankey/2026-08-04-sankey-direction.html
new file mode 100644
index 000000000..b9df08917
--- /dev/null
+++ b/_posts/plotly_js/basic/sankey/2026-08-04-sankey-direction.html
@@ -0,0 +1,38 @@
+---
+name: Flow Direction
+language: plotly_js
+suite: sankey
+order: 7
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  `direction` sets which way flows run along the `orientation` axis, so a diagram can be mirrored without reversing
+  your `link.source` and `link.target` data. The default, `'forward'`, puts sources first; `'reversed'` puts them last.
+  Combined with `orientation` (`'h'` or `'v'`) this gives four layouts: sources on the left, right, top, or bottom.
+  Node labels stay upright in every combination — only the flow geometry mirrors.
+
+  `direction` mirrors the finished layout: it does not reassign nodes to different columns. To change which column a node is placed in, use [Node Alignment](#node-alignment).
+---
+var data = [{
+  type: 'sankey',
+  orientation: 'h',
+  direction: 'reversed',
+  node: {
+    label: ['Coal', 'Gas', 'Solar', 'Grid', 'Residential', 'Industrial'],
+    pad: 15,
+    thickness: 20
+  },
+  link: {
+    source: [0, 1, 2, 3, 3],
+    target: [3, 3, 3, 4, 5],
+    value: [8, 4, 3, 9, 6]
+  }
+}];
+
+var layout = {
+  title: {text: "Reversed Flow (sources on the right)"},
+  width: 700,
+  height: 450
+};
+
+Plotly.newPlot('myDiv', data, layout);
diff --git a/_posts/plotly_js/basic/sankey/2026-08-04-sankey-sort.html b/_posts/plotly_js/basic/sankey/2026-08-04-sankey-sort.html
new file mode 100644
index 000000000..57d9fb10a
--- /dev/null
+++ b/_posts/plotly_js/basic/sankey/2026-08-04-sankey-sort.html
@@ -0,0 +1,40 @@
+---
+name: Node and Link Ordering
+language: plotly_js
+suite: sankey
+order: 6
+sitemap: false
+arrangement: horizontal
+markdown_content: |
+  By default (`sort: 'auto'`) the layout reorders nodes within a column, and links within a node, to reduce crossings.
+  Set `node.sort` and `link.sort` to `'input'` to keep the order given in `node.label` and in
+  `link.source` / `link.target` instead. Use `'input'` when the order carries meaning, or when you need a
+  deterministic layout across renders — for animations or side-by-side comparisons.
+
+  This figure pairs sources `A, B, C, D` one-to-one with targets `Z, Y, X, W`, a maximally crossed input. With
+  `'auto'`, the source column is flipped so the flows run horizontally; with `'input'`, every crossing is preserved.
+  `sort` is not honored on diagrams whose links form a cycle, which use a different layout algorithm.
+---
+var data = [{
+  type: 'sankey',
+  node: {
+    label: ['A', 'B', 'C', 'D', 'Z', 'Y', 'X', 'W'],
+    pad: 15,
+    thickness: 20,
+    sort: 'input'
+  },
+  link: {
+    source: [0, 1, 2, 3],
+    target: [4, 5, 6, 7],
+    value: [4, 3, 2, 1],
+    sort: 'input'
+  }
+}];
+
+var layout = {
+  title: {text: "Input Order Preserved (sort: 'input')"},
+  width: 700,
+  height: 450
+};
+
+Plotly.newPlot('myDiv', data, layout);

From 3a5f077e44db0dedaae173a3ea3002dfa2d28930 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Thu, 6 Aug 2026 09:05:03 -0600
Subject: [PATCH 21/25] Exclude deprecated languages from reference build,
 remove obsolete pages, add redirects

---
 _data/make_ref_pages.py                       |  8 ++++++-
 _includes/layouts/reference-side-nav.html     | 22 ++++++++++++++++++-
 .../2020-07-20-choroplethmapbox.html          | 16 +-------------
 .../javascript/2020-07-20-densitymapbox.html  | 16 +-------------
 .../javascript/2020-07-20-map.html            | 19 ++++++++++++++++
 .../javascript/2020-07-20-mapbox.html         | 17 +-------------
 .../javascript/2020-07-20-pointcloud.html     | 18 ---------------
 ...-heatmapgl.html => 2020-07-20-quiver.html} |  8 +++----
 .../javascript/2020-07-20-scattermapbox.html  | 16 +-------------
 .../python/2020-07-20-choroplethmapbox.html   | 16 +-------------
 .../python/2020-07-20-densitymapbox.html      | 16 +-------------
 .../python/2020-07-20-map.html                | 19 ++++++++++++++++
 .../python/2020-07-20-mapbox.html             | 17 +-------------
 .../python/2020-07-20-pointcloud.html         | 18 ---------------
 ...-heatmapgl.html => 2020-07-20-quiver.html} |  8 +++----
 .../python/2020-07-20-scattermapbox.html      | 16 +-------------
 16 files changed, 82 insertions(+), 168 deletions(-)
 create mode 100644 _posts/reference_pages/javascript/2020-07-20-map.html
 delete mode 100644 _posts/reference_pages/javascript/2020-07-20-pointcloud.html
 rename _posts/reference_pages/javascript/{2020-07-20-heatmapgl.html => 2020-07-20-quiver.html} (50%)
 create mode 100644 _posts/reference_pages/python/2020-07-20-map.html
 delete mode 100644 _posts/reference_pages/python/2020-07-20-pointcloud.html
 rename _posts/reference_pages/python/{2020-07-20-heatmapgl.html => 2020-07-20-quiver.html} (50%)

diff --git a/_data/make_ref_pages.py b/_data/make_ref_pages.py
index a76c18fb5..bbf92b3b4 100644
--- a/_data/make_ref_pages.py
+++ b/_data/make_ref_pages.py
@@ -3,7 +3,13 @@
 schema = json.load(open("plotschema.json"))
 
 
-for upperlang in ["Python", "JavaScript", "MATLAB", "R", "Julia", "F#"]:
+# Only Python and JavaScript are regenerated. The MATLAB, R, Julia, and F# reference
+# pages are frozen at whatever schema they were last built from: those languages are no
+# longer maintained, and their pages load pinned older plotly.js bundles (R/ggplot2 on
+# 1.58.4, Julia/MATLAB on 2.35.3 — see _includes/layouts/head.html), so regenerating them
+# from a current schema would document attributes their bundles don't have and drop ones
+# they do. Their existing files under _posts/reference_pages/<lang>/ are left untouched.
+for upperlang in ["Python", "JavaScript"]:
     lang = upperlang.lower()
     lang = "fsharp" if lang == "f#" else lang
     lang = "csharp" if lang == "c#" else lang
diff --git a/_includes/layouts/reference-side-nav.html b/_includes/layouts/reference-side-nav.html
index 18018b187..efaf52640 100644
--- a/_includes/layouts/reference-side-nav.html
+++ b/_includes/layouts/reference-side-nav.html
@@ -1,3 +1,8 @@
+{% comment %}Python and JavaScript track the current plotly.js schema; the other
+languages' reference pages are frozen on older bundles, so they keep the legacy
+entries. See the note at the top of _data/make_ref_pages.py.{% endcomment %}
+{% assign v4ref = false %}
+{% if langue == "javascript" or langue == "python" %}{% assign v4ref = true %}{% endif %}
 <details style="color: white; margin-top: 20px">
   <summary>Simple Traces</summary>
   <nav class="--sidebar-body watch" id="where">
@@ -22,9 +27,11 @@
         <a href="/{{ langue }}/reference/heatmap">Heatmap</a>
       </li>
 
+{% unless v4ref %}
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/heatmapgl">Heatmap GL</a>
       </li>
+{% endunless %}
 
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/image">Image</a>
@@ -34,6 +41,12 @@
         <a href="/{{ langue }}/reference/contour">Contour</a>
       </li>
 
+{% if v4ref %}
+      <li class="--sidebar-item">
+        <a href="/{{ langue }}/reference/quiver">Quiver</a>
+      </li>
+{% endif %}
+
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/table">Table</a>
       </li>
@@ -152,25 +165,32 @@
         <a href="/{{ langue }}/reference/scattermap">Scatter Map</a>
       </li>
 
+{% unless v4ref %}
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/scattermapbox">Scatter Mapbox</a>
       </li>
+{% endunless %}
 
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/choroplethmap">Choropleth Map</a>
       </li>
 
+{% unless v4ref %}
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/choroplethmapbox">Choropleth Mapbox</a>
       </li>
+{% endunless %}
 
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/densitymap">Density Map</a>
       </li>
 
+{% unless v4ref %}
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/densitymapbox">Density Mapbox</a>
       </li>
+{% endunless %}
+
     </ul>
   </nav>
 </details>
@@ -295,7 +315,7 @@
         <a href="/{{ langue }}/reference/layout/geo/">Geo</a>
       </li>
       <li class="--sidebar-item">
-        <a href="/{{ langue }}/reference/layout/mapbox/">Mapbox</a>
+        {% if v4ref %}<a href="/{{ langue }}/reference/layout/map/">Map</a>{% else %}<a href="/{{ langue }}/reference/layout/mapbox/">Mapbox</a>{% endif %}
       </li>
       <li class="--sidebar-item">
         <a href="/{{ langue }}/reference/layout/polar/">Polar</a>
diff --git a/_posts/reference_pages/javascript/2020-07-20-choroplethmapbox.html b/_posts/reference_pages/javascript/2020-07-20-choroplethmapbox.html
index f6d7694e4..fa235a4f5 100644
--- a/_posts/reference_pages/javascript/2020-07-20-choroplethmapbox.html
+++ b/_posts/reference_pages/javascript/2020-07-20-choroplethmapbox.html
@@ -1,18 +1,4 @@
 ---
 permalink: /javascript/reference/choroplethmapbox/
-layout: langindex
-page_type: reference
-language: plotly_js
-name: choroplethmapbox Traces
-description: Figure attribute reference for Plotly's JavaScript open-source graphing library.
+redirect_to: /javascript/reference/choroplethmap/
 ---
-
-<h2>JavaScript Figure Reference: <code>choroplethmapbox</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="choroplethmapbox" trace_data=site.data.plotschema.traces.choroplethmapbox %}
-
-  </div>
-</div>
diff --git a/_posts/reference_pages/javascript/2020-07-20-densitymapbox.html b/_posts/reference_pages/javascript/2020-07-20-densitymapbox.html
index 51e34b0c0..83c2a3490 100644
--- a/_posts/reference_pages/javascript/2020-07-20-densitymapbox.html
+++ b/_posts/reference_pages/javascript/2020-07-20-densitymapbox.html
@@ -1,18 +1,4 @@
 ---
 permalink: /javascript/reference/densitymapbox/
-layout: langindex
-page_type: reference
-language: plotly_js
-name: densitymapbox Traces
-description: Figure attribute reference for Plotly's JavaScript open-source graphing library.
+redirect_to: /javascript/reference/densitymap/
 ---
-
-<h2>JavaScript Figure Reference: <code>densitymapbox</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="densitymapbox" trace_data=site.data.plotschema.traces.densitymapbox %}
-
-  </div>
-</div>
diff --git a/_posts/reference_pages/javascript/2020-07-20-map.html b/_posts/reference_pages/javascript/2020-07-20-map.html
new file mode 100644
index 000000000..ef85fac5b
--- /dev/null
+++ b/_posts/reference_pages/javascript/2020-07-20-map.html
@@ -0,0 +1,19 @@
+---
+permalink: /javascript/reference/layout/map/
+layout: langindex
+page_type: reference
+language: plotly_js
+name: layout.map
+description: Figure attribute reference for Plotly's JavaScript open-source graphing library.
+---
+
+<h2>JavaScript Figure Reference: <code>layout.map</code></h2>
+
+<div class="row">
+  <div class="eight columns" style="max-width: 900px;">
+
+    {% assign attribute=site.data.plotschema.layout.layoutAttributes %}
+    {% include posts/reference-block.html parentlink="layout" block="layout" parentpath="layout" mustmatch="map" %}
+    
+  </div>
+</div>
diff --git a/_posts/reference_pages/javascript/2020-07-20-mapbox.html b/_posts/reference_pages/javascript/2020-07-20-mapbox.html
index a79d682ba..34b7406c1 100644
--- a/_posts/reference_pages/javascript/2020-07-20-mapbox.html
+++ b/_posts/reference_pages/javascript/2020-07-20-mapbox.html
@@ -1,19 +1,4 @@
 ---
 permalink: /javascript/reference/layout/mapbox/
-layout: langindex
-page_type: reference
-language: plotly_js
-name: layout.mapbox
-description: Figure attribute reference for Plotly's JavaScript open-source graphing library.
+redirect_to: /javascript/reference/layout/map/
 ---
-
-<h2>JavaScript Figure Reference: <code>layout.mapbox</code></h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% assign attribute=site.data.plotschema.layout.layoutAttributes %}
-    {% include posts/reference-block.html parentlink="layout" block="layout" parentpath="layout" mustmatch="mapbox" %}
-    
-  </div>
-</div>
diff --git a/_posts/reference_pages/javascript/2020-07-20-pointcloud.html b/_posts/reference_pages/javascript/2020-07-20-pointcloud.html
deleted file mode 100644
index 7cfdfdf9c..000000000
--- a/_posts/reference_pages/javascript/2020-07-20-pointcloud.html
+++ /dev/null
@@ -1,18 +0,0 @@
----
-permalink: /javascript/reference/pointcloud/
-layout: langindex
-page_type: reference
-language: plotly_js
-name: pointcloud Traces
-description: Figure attribute reference for Plotly's JavaScript open-source graphing library.
----
-
-<h2>JavaScript Figure Reference: <code>pointcloud</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="pointcloud" trace_data=site.data.plotschema.traces.pointcloud %}
-
-  </div>
-</div>
diff --git a/_posts/reference_pages/javascript/2020-07-20-heatmapgl.html b/_posts/reference_pages/javascript/2020-07-20-quiver.html
similarity index 50%
rename from _posts/reference_pages/javascript/2020-07-20-heatmapgl.html
rename to _posts/reference_pages/javascript/2020-07-20-quiver.html
index f6971851a..9a9a273fe 100644
--- a/_posts/reference_pages/javascript/2020-07-20-heatmapgl.html
+++ b/_posts/reference_pages/javascript/2020-07-20-quiver.html
@@ -1,18 +1,18 @@
 ---
-permalink: /javascript/reference/heatmapgl/
+permalink: /javascript/reference/quiver/
 layout: langindex
 page_type: reference
 language: plotly_js
-name: heatmapgl Traces
+name: quiver Traces
 description: Figure attribute reference for Plotly's JavaScript open-source graphing library.
 ---
 
-<h2>JavaScript Figure Reference: <code>heatmapgl</code> Traces</h2>
+<h2>JavaScript Figure Reference: <code>quiver</code> Traces</h2>
 
 <div class="row">
   <div class="eight columns" style="max-width: 900px;">
 
-    {% include posts/reference-trace.html trace_name="heatmapgl" trace_data=site.data.plotschema.traces.heatmapgl %}
+    {% include posts/reference-trace.html trace_name="quiver" trace_data=site.data.plotschema.traces.quiver %}
 
   </div>
 </div>
diff --git a/_posts/reference_pages/javascript/2020-07-20-scattermapbox.html b/_posts/reference_pages/javascript/2020-07-20-scattermapbox.html
index e1678d9b4..4692e29c8 100644
--- a/_posts/reference_pages/javascript/2020-07-20-scattermapbox.html
+++ b/_posts/reference_pages/javascript/2020-07-20-scattermapbox.html
@@ -1,18 +1,4 @@
 ---
 permalink: /javascript/reference/scattermapbox/
-layout: langindex
-page_type: reference
-language: plotly_js
-name: scattermapbox Traces
-description: Figure attribute reference for Plotly's JavaScript open-source graphing library.
+redirect_to: /javascript/reference/scattermap/
 ---
-
-<h2>JavaScript Figure Reference: <code>scattermapbox</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="scattermapbox" trace_data=site.data.plotschema.traces.scattermapbox %}
-
-  </div>
-</div>
diff --git a/_posts/reference_pages/python/2020-07-20-choroplethmapbox.html b/_posts/reference_pages/python/2020-07-20-choroplethmapbox.html
index f8635576d..719cacb78 100644
--- a/_posts/reference_pages/python/2020-07-20-choroplethmapbox.html
+++ b/_posts/reference_pages/python/2020-07-20-choroplethmapbox.html
@@ -1,18 +1,4 @@
 ---
 permalink: /python/reference/choroplethmapbox/
-layout: langindex
-page_type: reference
-language: python
-name: choroplethmapbox Traces
-description: Figure attribute reference for Plotly's Python open-source graphing library.
+redirect_to: /python/reference/choroplethmap/
 ---
-
-<h2>Python Figure Reference: <code>choroplethmapbox</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="choroplethmapbox" trace_data=site.data.plotschema.traces.choroplethmapbox %}
-
-  </div>
-</div>
diff --git a/_posts/reference_pages/python/2020-07-20-densitymapbox.html b/_posts/reference_pages/python/2020-07-20-densitymapbox.html
index e29c6ee67..9f485185d 100644
--- a/_posts/reference_pages/python/2020-07-20-densitymapbox.html
+++ b/_posts/reference_pages/python/2020-07-20-densitymapbox.html
@@ -1,18 +1,4 @@
 ---
 permalink: /python/reference/densitymapbox/
-layout: langindex
-page_type: reference
-language: python
-name: densitymapbox Traces
-description: Figure attribute reference for Plotly's Python open-source graphing library.
+redirect_to: /python/reference/densitymap/
 ---
-
-<h2>Python Figure Reference: <code>densitymapbox</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="densitymapbox" trace_data=site.data.plotschema.traces.densitymapbox %}
-
-  </div>
-</div>
diff --git a/_posts/reference_pages/python/2020-07-20-map.html b/_posts/reference_pages/python/2020-07-20-map.html
new file mode 100644
index 000000000..08f54c7e9
--- /dev/null
+++ b/_posts/reference_pages/python/2020-07-20-map.html
@@ -0,0 +1,19 @@
+---
+permalink: /python/reference/layout/map/
+layout: langindex
+page_type: reference
+language: python
+name: layout.map
+description: Figure attribute reference for Plotly's Python open-source graphing library.
+---
+
+<h2>Python Figure Reference: <code>layout.map</code></h2>
+
+<div class="row">
+  <div class="eight columns" style="max-width: 900px;">
+
+    {% assign attribute=site.data.plotschema.layout.layoutAttributes %}
+    {% include posts/reference-block.html parentlink="layout" block="layout" parentpath="layout" mustmatch="map" %}
+    
+  </div>
+</div>
diff --git a/_posts/reference_pages/python/2020-07-20-mapbox.html b/_posts/reference_pages/python/2020-07-20-mapbox.html
index 7a033625b..140e8ee80 100644
--- a/_posts/reference_pages/python/2020-07-20-mapbox.html
+++ b/_posts/reference_pages/python/2020-07-20-mapbox.html
@@ -1,19 +1,4 @@
 ---
 permalink: /python/reference/layout/mapbox/
-layout: langindex
-page_type: reference
-language: python
-name: layout.mapbox
-description: Figure attribute reference for Plotly's Python open-source graphing library.
+redirect_to: /python/reference/layout/map/
 ---
-
-<h2>Python Figure Reference: <code>layout.mapbox</code></h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% assign attribute=site.data.plotschema.layout.layoutAttributes %}
-    {% include posts/reference-block.html parentlink="layout" block="layout" parentpath="layout" mustmatch="mapbox" %}
-    
-  </div>
-</div>
diff --git a/_posts/reference_pages/python/2020-07-20-pointcloud.html b/_posts/reference_pages/python/2020-07-20-pointcloud.html
deleted file mode 100644
index 4df8513d4..000000000
--- a/_posts/reference_pages/python/2020-07-20-pointcloud.html
+++ /dev/null
@@ -1,18 +0,0 @@
----
-permalink: /python/reference/pointcloud/
-layout: langindex
-page_type: reference
-language: python
-name: pointcloud Traces
-description: Figure attribute reference for Plotly's Python open-source graphing library.
----
-
-<h2>Python Figure Reference: <code>pointcloud</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="pointcloud" trace_data=site.data.plotschema.traces.pointcloud %}
-
-  </div>
-</div>
diff --git a/_posts/reference_pages/python/2020-07-20-heatmapgl.html b/_posts/reference_pages/python/2020-07-20-quiver.html
similarity index 50%
rename from _posts/reference_pages/python/2020-07-20-heatmapgl.html
rename to _posts/reference_pages/python/2020-07-20-quiver.html
index 3a19bc8c7..a2fb60e22 100644
--- a/_posts/reference_pages/python/2020-07-20-heatmapgl.html
+++ b/_posts/reference_pages/python/2020-07-20-quiver.html
@@ -1,18 +1,18 @@
 ---
-permalink: /python/reference/heatmapgl/
+permalink: /python/reference/quiver/
 layout: langindex
 page_type: reference
 language: python
-name: heatmapgl Traces
+name: quiver Traces
 description: Figure attribute reference for Plotly's Python open-source graphing library.
 ---
 
-<h2>Python Figure Reference: <code>heatmapgl</code> Traces</h2>
+<h2>Python Figure Reference: <code>quiver</code> Traces</h2>
 
 <div class="row">
   <div class="eight columns" style="max-width: 900px;">
 
-    {% include posts/reference-trace.html trace_name="heatmapgl" trace_data=site.data.plotschema.traces.heatmapgl %}
+    {% include posts/reference-trace.html trace_name="quiver" trace_data=site.data.plotschema.traces.quiver %}
 
   </div>
 </div>
diff --git a/_posts/reference_pages/python/2020-07-20-scattermapbox.html b/_posts/reference_pages/python/2020-07-20-scattermapbox.html
index 36d389ee1..58ba4b17f 100644
--- a/_posts/reference_pages/python/2020-07-20-scattermapbox.html
+++ b/_posts/reference_pages/python/2020-07-20-scattermapbox.html
@@ -1,18 +1,4 @@
 ---
 permalink: /python/reference/scattermapbox/
-layout: langindex
-page_type: reference
-language: python
-name: scattermapbox Traces
-description: Figure attribute reference for Plotly's Python open-source graphing library.
+redirect_to: /python/reference/scattermap/
 ---
-
-<h2>Python Figure Reference: <code>scattermapbox</code> Traces</h2>
-
-<div class="row">
-  <div class="eight columns" style="max-width: 900px;">
-
-    {% include posts/reference-trace.html trace_name="scattermapbox" trace_data=site.data.plotschema.traces.scattermapbox %}
-
-  </div>
-</div>

From 070be5cb47f55b245985ba54cf1900dacf5996de Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Thu, 6 Aug 2026 09:23:59 -0600
Subject: [PATCH 22/25] Update guide thumbnails

---
 _posts/plotly_js/guides/typescript/2026-08-04-typescript.md     | 2 +-
 .../guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md        | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/_posts/plotly_js/guides/typescript/2026-08-04-typescript.md b/_posts/plotly_js/guides/typescript/2026-08-04-typescript.md
index 937926d0b..57db0a4b1 100644
--- a/_posts/plotly_js/guides/typescript/2026-08-04-typescript.md
+++ b/_posts/plotly_js/guides/typescript/2026-08-04-typescript.md
@@ -8,7 +8,7 @@ order: 4
 page_type: u-guide
 permalink: javascript/guides/typescript/
 sitemap: false
-thumbnail: thumbnail/mixed.jpg
+thumbnail: thumbnail/theming-and-templates.png
 ---
 # Using Plotly.js with TypeScript
 
diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
index 2f7a9292a..f86fff7d3 100644
--- a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -8,7 +8,7 @@ order: 1
 page_type: u-guide
 permalink: javascript/guides/whats-new-in-v4/
 sitemap: false
-thumbnail: thumbnail/mixed.jpg
+thumbnail: thumbnail/quiver-plot.jpg
 ---
 # What's New in Plotly.js v4
 

From b658a85a21956ed38cd9c7ba5c134728a8f98729 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Thu, 6 Aug 2026 10:50:20 -0600
Subject: [PATCH 23/25] Update share chart images

---
 .../share_with_plotly_cloud_button.png        | Bin 21323 -> 18089 bytes
 .../share_with_plotly_cloud_dialog.png        | Bin 22903 -> 30254 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png b/all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png
index 4dae7fc02bcd543e80a2f09fd1a05b22b621727c..eeca3a4f832b768464f62acebdcfb7a0644866f8 100644
GIT binary patch
literal 18089
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
CmX3=6

literal 21323
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

diff --git a/all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png b/all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png
index 192482fe452512c3f42c50db327f416a95e28d70..7de949cd610a39fdcd7c5030d65e8180825f7b3c 100644
GIT binary patch
literal 30254
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

literal 22903
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


From 55378a7767660419f8dfba252cf302f2ee55c42d Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Thu, 6 Aug 2026 11:04:04 -0600
Subject: [PATCH 24/25] Update language to match current version

---
 .../2015-09-24-config-showSendToCloud.html       | 14 ++++++++------
 .../2016-05-20-static-image.md                   |  2 +-
 .../2018-12-17-how-to-tick-format-layout.html    |  4 ----
 .../2026-07-17-migrating-to-v4.md                |  2 +-
 .../2026-07-20-whats-new-in-v4.md                | 16 ++++++++++------
 5 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html b/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html
index 3373b7748..9b7df5f52 100644
--- a/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html
+++ b/_posts/plotly_js/fundamentals/config-options/2015-09-24-config-showSendToCloud.html
@@ -1,16 +1,18 @@
 ---
-name: Share with Plotly Cloud
+name: Share a Chart to Plotly Cloud
 language: plotly_js
 suite: configuration
 order: 6
 sitemap: false
 arrangement: horizontal
 markdown_content: |
-  The `sendChartToCloud` modebar button sends the chart to [Plotly Cloud](https://cloud.plotly.com) and opens it in a
-  new tab, where you can copy a sharing link and set the chart's visibility. A Plotly Cloud account is required.
+  The `sendChartToCloud` modebar button, labelled "Share chart…", sends the chart to
+  [Plotly Cloud](https://cloud.plotly.com) and opens it in a new tab, where you can copy a sharing link and set the
+  chart's visibility. Clicking it first brings up a confirmation dialog naming the destination. A Plotly Cloud account
+  is required.
 
   The button is shown by default. Set `showSendToCloud: false` to hide it, or set `plotlyServerURL` to send charts to
-  a self-hosted or alternate server instead of `cloud.plotly.com`.
+  a self-hosted or alternate server instead of the default `https://cloud.plotly.com/newchart`.
 ---
 var data = [{
   values: [19, 26, 55],
@@ -20,13 +22,13 @@
 
 var layout = {
   title: {
-      text: 'Share with Plotly Cloud'
+      text: 'Share a Chart to Plotly Cloud'
   }
 };
 
 var config = {
   showSendToCloud: true,
-  plotlyServerURL: "https://cloud.plotly.com"
+  plotlyServerURL: "https://cloud.plotly.com/newchart"
 };
 
 Plotly.newPlot('myDiv', data, layout, config);
diff --git a/_posts/plotly_js/fundamentals/static-image-export/2016-05-20-static-image.md b/_posts/plotly_js/fundamentals/static-image-export/2016-05-20-static-image.md
index cf77e1f0d..2b61807a7 100644
--- a/_posts/plotly_js/fundamentals/static-image-export/2016-05-20-static-image.md
+++ b/_posts/plotly_js/fundamentals/static-image-export/2016-05-20-static-image.md
@@ -60,7 +60,7 @@ You can also save the image using different formats.
 
 The common image formats: 'PNG', 'JPG/JPEG' are supported. In addition, formats like 'EPS', 'SVG' and 'PDF' are also available for user with a Personal or Professional subscription. You can get more details on our [pricing page] (https://plotly.com/products/cloud/)
 
-**Note:** It is important to note that any figures containing WebGL traces (i.e. of type scattergl, heatmapgl, contourgl, scatter3d, surface, mesh3d, scatterpolargl, cone, streamtube, splom, or parcoords) that are exported in a vector format like SVG, EPS or PDF will include encapsulated rasters instead of vectors for some parts of the image.
+**Note:** It is important to note that any figures containing WebGL traces (i.e. of type scattergl, scatter3d, surface, mesh3d, scatterpolargl, cone, streamtube, splom, or parcoords) that are exported in a vector format like SVG, EPS or PDF will include encapsulated rasters instead of vectors for some parts of the image.
 
 ## Saving as PNG ##
       img_png.attr("src", url);
diff --git a/_posts/plotly_js/fundamentals/tick-format/2018-12-17-how-to-tick-format-layout.html b/_posts/plotly_js/fundamentals/tick-format/2018-12-17-how-to-tick-format-layout.html
index 4c4254926..bb06f3779 100644
--- a/_posts/plotly_js/fundamentals/tick-format/2018-12-17-how-to-tick-format-layout.html
+++ b/_posts/plotly_js/fundamentals/tick-format/2018-12-17-how-to-tick-format-layout.html
@@ -27,10 +27,6 @@
     tickvals: [ /* */ ],
     /* Set the text displayed at the ticks position via tickvals */
     ticktext: [ /* */ ],
-    /* Set the source reference for tickvals */
-    tickvalssrc: '',
-    /* Set the source reference for ticktext */
-    tickvtextsrc: '',
 
     /* Set the tick label formatting rule using d3 formatting mini-languages */
     tickformat: '',
diff --git a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
index 22f76179e..b11cd824f 100644
--- a/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
+++ b/_posts/plotly_js/guides/migrating-to-v4/2026-07-17-migrating-to-v4.md
@@ -101,7 +101,7 @@ Plotly.newPlot(gd, data, layout, {
 });
 ```
 
-The **"Share with Plotly Cloud" button (`sendChartToCloud`) is now on by
+The **"Share chart…" button (`sendChartToCloud`) is now on by
 default**. If you don't want the button visible, it can be turned off as follows:
 
 ```js
diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
index f86fff7d3..220186c31 100644
--- a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -137,15 +137,19 @@ A larger example showing arrows colored by magnitude:
 [#7854](https://github.com/plotly/plotly.js/pull/7854), and
 [#7909](https://github.com/plotly/plotly.js/pull/7909).*
 
-Plotly.js now offers a modebar button which sends the current chart to [Plotly Cloud](https://cloud.plotly.com) to generate a shareable link. Sharing the chart opens Plotly Cloud in a new tab, where you can copy the sharing link and adjust visibility settings. A Plotly Cloud account is required.
+Plotly.js now offers a modebar button, labelled "Share chart…", which sends the
+current chart to [Plotly Cloud](https://cloud.plotly.com) to generate a shareable
+link. Sharing the chart opens Plotly Cloud in a new tab, where you can copy the
+sharing link and adjust visibility settings. A Plotly Cloud account is required.
 
 The button is enabled by default in v4:
 
-![Share with Plotly Cloud button](/all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png)
+![The "Share chart…" modebar button](/all_static/images/whats-new-in-v4/share_with_plotly_cloud_button.png)
 
-Clicking the button brings up the share dialog:
+Clicking the button brings up a confirmation dialog, which names the destination
+and offers **Cancel** and **Share**:
 
-![Share with Plotly Cloud dialog](/all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png)
+![The "Share chart" confirmation dialog](/all_static/images/whats-new-in-v4/share_with_plotly_cloud_dialog.png)
 
 ### Config
 
@@ -153,8 +157,8 @@ The button is controlled by two config options:
 
 | Config option | Default | Purpose |
 |---|---|---|
-| `showSendToCloud` | `true` | Whether the "Share with Plotly Cloud" modebar button is rendered. |
-| `plotlyServerURL` | `'cloud.plotly.com'` | The endpoint the button posts to. Override to point at a self-hosted or alternate server. |
+| `showSendToCloud` | `true` | Whether the "Share chart…" modebar button is rendered. |
+| `plotlyServerURL` | `'https://cloud.plotly.com/newchart'` | The endpoint the button posts to. Override to point at a self-hosted or alternate server. |
 
 Hide the button by setting `showSendToCloud: false`:
 

From 9ea07144ac677eae6eca7ea89c9cc0a344220897 Mon Sep 17 00:00:00 2001
From: Cameron DeCoster <cameron.decoster@gmail.com>
Date: Thu, 6 Aug 2026 12:51:46 -0600
Subject: [PATCH 25/25] Add antimeridian crossing example image

---
 .../2026-07-20-whats-new-in-v4.md               |   2 ++
 .../images/whats-new-in-v4/map_fitbounds.png    | Bin 0 -> 91599 bytes
 2 files changed, 2 insertions(+)
 create mode 100644 all_static/images/whats-new-in-v4/map_fitbounds.png

diff --git a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
index 220186c31..cfbc916d4 100644
--- a/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
+++ b/_posts/plotly_js/guides/whats-new-in-v4/2026-07-20-whats-new-in-v4.md
@@ -485,6 +485,8 @@ range rather than the long-way-around view. For example, `lon: [131.8855,
 -179]` frames as `[131.8855, 181]` (a ~49° span across the antimeridian)
 instead of the naive `[-179, 131.8855]` (~311° the wrong way).
 
+![naive vs compact auto-fit](/all_static/images/whats-new-in-v4/map_fitbounds.png)
+
 ### `map.bounds` is unaffected
 
 The `map.bounds` layout attribute (which restricts panning) is a separate
diff --git a/all_static/images/whats-new-in-v4/map_fitbounds.png b/all_static/images/whats-new-in-v4/map_fitbounds.png
new file mode 100644
index 0000000000000000000000000000000000000000..33100af002e18eceb062c9a5716d69aaceaaeba1
GIT binary patch
literal 91599
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

literal 0
HcmV?d00001