diff --git a/packages/vx-demo/src/sandboxes/vx-legend/Example.tsx b/packages/vx-demo/src/sandboxes/vx-legend/Example.tsx
index 2a68493e1..1dffd2d2a 100644
--- a/packages/vx-demo/src/sandboxes/vx-legend/Example.tsx
+++ b/packages/vx-demo/src/sandboxes/vx-legend/Example.tsx
@@ -71,7 +71,7 @@ export default function Example({ events = false }: { events?: boolean }) {
   return (
     <div className="legends">
       <LegendDemo title="Size">
-        <LegendSize<number> scale={sizeScale}>
+        <LegendSize scale={sizeScale}>
           {labels =>
             labels.map(label => {
               const size = sizeScale(label.datum);
@@ -96,7 +96,7 @@ export default function Example({ events = false }: { events?: boolean }) {
         </LegendSize>
       </LegendDemo>
       <LegendDemo title="Quantile">
-        <LegendQuantile<string> scale={quantileScale}>
+        <LegendQuantile scale={quantileScale}>
           {labels =>
             labels.map((label, i) => (
               <LegendItem
@@ -197,7 +197,7 @@ export default function Example({ events = false }: { events?: boolean }) {
         </LegendOrdinal>
       </LegendDemo>
       <LegendDemo title="Custom Legend">
-        <Legend<string, React.FC | React.ReactNode, typeof shapeScale> scale={shapeScale}>
+        <Legend scale={shapeScale}>
           {labels => (
             <div style={{ display: 'flex', flexDirection: 'row' }}>
               {labels.map((label, i) => {
diff --git a/packages/vx-legend/package.json b/packages/vx-legend/package.json
index e32f7571d..2ddbe2730 100644
--- a/packages/vx-legend/package.json
+++ b/packages/vx-legend/package.json
@@ -35,13 +35,10 @@
   },
   "dependencies": {
     "@types/classnames": "^2.2.9",
-    "@types/d3-scale": "^2.1.1",
     "@types/react": "*",
     "@vx/group": "0.0.198",
+    "@vx/scale": "0.0.198",
     "classnames": "^2.2.5",
     "prop-types": "^15.5.10"
-  },
-  "devDependencies": {
-    "@vx/scale": "0.0.198"
   }
 }
diff --git a/packages/vx-legend/src/legends/Legend/index.tsx b/packages/vx-legend/src/legends/Legend/index.tsx
index 247589511..7fae77b47 100644
--- a/packages/vx-legend/src/legends/Legend/index.tsx
+++ b/packages/vx-legend/src/legends/Legend/index.tsx
@@ -1,5 +1,6 @@
 import React from 'react';
 import cx from 'classnames';
+import { AnyD3Scale, ScaleInput } from '@vx/scale';
 import LegendItem from './LegendItem';
 import LegendLabel, { LegendLabelProps } from './LegendLabel';
 import LegendShape from './LegendShape';
@@ -7,22 +8,21 @@ import valueOrIdentity, { valueOrIdentityString } from '../../util/valueOrIdenti
 import labelTransformFactory from '../../util/labelTransformFactory';
 import {
   FlexDirection,
-  ScaleType,
   FormattedLabel,
   LabelFormatter,
   LabelFormatterFactory,
   LegendShape as LegendShapeType,
 } from '../../types';
 
-export type LegendProps<Datum, Output, Scale = ScaleType<Datum, Output>> = {
+export type LegendProps<Scale extends AnyD3Scale> = {
   /** Optional render function override. */
-  children?: (labels: FormattedLabel<Datum, Output>[]) => React.ReactNode;
+  children?: (labels: FormattedLabel<ScaleInput<Scale>, ReturnType<Scale>>[]) => React.ReactNode;
   /** Classname to be applied to legend container. */
   className?: string;
   /** Styles to be applied to the legend container. */
   style?: React.CSSProperties;
   /** Legend domain. */
-  domain?: Datum[];
+  domain?: ScaleInput<Scale>[];
   /** Width of the legend shape. */
   shapeWidth?: string | number;
   /** Height of the legend shape. */
@@ -44,17 +44,21 @@ export type LegendProps<Datum, Output, Scale = ScaleType<Datum, Output>> = {
   /** Flex direction of legend items. */
   itemDirection?: FlexDirection;
   /** Legend item fill accessor function. */
-  fill?: (label: FormattedLabel<Datum, Output>) => string | number | undefined;
+  fill?: (
+    label: FormattedLabel<ScaleInput<Scale>, ReturnType<Scale>>,
+  ) => string | number | undefined;
   /** Legend item size accessor function. */
-  size?: (label: FormattedLabel<Datum, Output>) => string | number | undefined;
+  size?: (
+    label: FormattedLabel<ScaleInput<Scale>, ReturnType<Scale>>,
+  ) => string | number | undefined;
   /** Legend shape string preset or Element or Component. */
-  shape?: LegendShapeType<Datum, Output>;
+  shape?: LegendShapeType<ScaleInput<Scale>, ReturnType<Scale>>;
   /** Styles applied to legend shapes. */
-  shapeStyle?: (label: FormattedLabel<Datum, Output>) => React.CSSProperties;
+  shapeStyle?: (label: FormattedLabel<ScaleInput<Scale>, ReturnType<Scale>>) => React.CSSProperties;
   /** Given a legend item and its index, returns an item label. */
-  labelFormat?: LabelFormatter<Datum>;
+  labelFormat?: LabelFormatter<ScaleInput<Scale>>;
   /** Given the legend scale and labelFormatter, returns a label with datum, index, value, and label. */
-  labelTransform?: LabelFormatterFactory<Datum, Output, Scale>;
+  labelTransform?: LabelFormatterFactory<Scale>;
   /** Additional props to be set on LegendLabel. */
   legendLabelProps?: Partial<LegendLabelProps>;
 };
@@ -63,7 +67,7 @@ const defaultStyle = {
   display: 'flex',
 };
 
-export default function Legend<Datum, Output, Scale = ScaleType<Datum, Output>>({
+export default function Legend<Scale extends AnyD3Scale>({
   className,
   style = defaultStyle,
   scale,
@@ -86,13 +90,14 @@ export default function Legend<Datum, Output, Scale = ScaleType<Datum, Output>>(
   legendLabelProps,
   children,
   ...legendItemProps
-}: LegendProps<Datum, Output, Scale>) {
+}: LegendProps<Scale>) {
   // `Scale extends ScaleType` constraint is tricky
   //  could consider removing `scale` altogether in the future and making `domain: Datum[]` required
   // @ts-ignore doesn't like `.domain()`
   const domain = inputDomain || (('domain' in scale ? scale.domain() : []) as Datum[]);
   const labelFormatter = labelTransform({ scale, labelFormat });
   const labels = domain.map(labelFormatter);
+  // eslint-disable-next-line react/jsx-no-useless-fragment
   if (children) return <>{children(labels)}</>;
 
   return (
diff --git a/packages/vx-legend/src/legends/Linear.tsx b/packages/vx-legend/src/legends/Linear.tsx
index f6a9caea0..0e0a6e2ff 100644
--- a/packages/vx-legend/src/legends/Linear.tsx
+++ b/packages/vx-legend/src/legends/Linear.tsx
@@ -1,39 +1,22 @@
 import React from 'react';
+import { PickD3Scale } from '@vx/scale';
 import Legend, { LegendProps } from './Legend';
-import { ScaleLinear } from '../types';
+import defaultDomain from '../util/defaultDomain';
 
-export type LegendLinearProps<Output> = {
-  steps?: number;
-} & LegendProps<number, Output, ScaleLinear<number, Output>>;
-
-export function defaultDomain<Output>({
-  steps = 5,
-  scale,
-}: Pick<LegendLinearProps<Output>, 'steps' | 'scale'>) {
-  const domain = scale.domain();
-  const start = domain[0];
-  const end = domain[domain.length - 1];
-  const step = (end - start) / (steps - 1);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyLinearScale = PickD3Scale<'linear', any>;
 
-  return new Array(steps).fill(1).reduce((acc, cur, i) => {
-    acc.push(start + i * step);
-    return acc;
-  }, []);
-}
+export type LegendLinearProps<Scale extends AnyLinearScale> = {
+  steps?: number;
+} & LegendProps<Scale>;
 
 /** Linear scales map from continuous inputs to continuous outputs. */
-export default function Linear<Output>({
+export default function Linear<Scale extends AnyLinearScale>({
   scale,
   domain: inputDomain,
   steps = 5,
   ...restProps
-}: LegendLinearProps<Output>) {
+}: LegendLinearProps<Scale>) {
   const domain = inputDomain || defaultDomain({ steps, scale });
-  return (
-    <Legend<number, Output, ScaleLinear<number, Output>>
-      scale={scale}
-      domain={domain}
-      {...restProps}
-    />
-  );
+  return <Legend<Scale> scale={scale} domain={domain} {...restProps} />;
 }
diff --git a/packages/vx-legend/src/legends/Ordinal.tsx b/packages/vx-legend/src/legends/Ordinal.tsx
index aa5e2e502..7856fc266 100644
--- a/packages/vx-legend/src/legends/Ordinal.tsx
+++ b/packages/vx-legend/src/legends/Ordinal.tsx
@@ -1,16 +1,13 @@
 import React from 'react';
+import { PickD3Scale } from '@vx/scale';
 import Legend, { LegendProps } from './Legend';
-import { ScaleOrdinal } from '../types';
 
-export type LegendOrdinalProps<Input extends { toString(): string }, Output> = LegendProps<
-  string,
-  Output,
-  ScaleOrdinal<Input, Output>
->;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyOrdinalScale = PickD3Scale<'ordinal', any, any>;
+
+export type LegendOrdinalProps<Scale extends AnyOrdinalScale> = LegendProps<Scale>;
 
 /** Ordinal scales map from strings to an Output type. */
-export default function Ordinal<Input extends { toString(): string }, Output>(
-  props: LegendOrdinalProps<Input, Output>,
-) {
-  return <Legend<string, Output, ScaleOrdinal<Input, Output>> {...props} />;
+export default function Ordinal<Scale extends AnyOrdinalScale>(props: LegendOrdinalProps<Scale>) {
+  return <Legend<Scale> {...props} />;
 }
diff --git a/packages/vx-legend/src/legends/Quantile.tsx b/packages/vx-legend/src/legends/Quantile.tsx
index 1b8e47ae6..34cf980ef 100644
--- a/packages/vx-legend/src/legends/Quantile.tsx
+++ b/packages/vx-legend/src/legends/Quantile.tsx
@@ -1,22 +1,22 @@
 import React from 'react';
-
+import { PickD3Scale } from '@vx/scale';
 import Legend, { LegendProps } from './Legend';
-import { LabelFormatterFactory, ScaleQuantile } from '../types';
+import { LabelFormatterFactory } from '../types';
+import identity from '../util/identity';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyQuantileScale = PickD3Scale<'quantile', any>;
 
-export type LegendQuantileProps<Output> = {
+type FactoryProps = {
   labelDelimiter?: string;
-  labelTransform?: LabelFormatterFactory<number, Output, ScaleQuantile<number, Output>>;
-  scale: ScaleQuantile<number, Output>;
-} & Omit<LegendProps<number, Output, ScaleQuantile<number, Output>>, 'scale' | 'labelTransform'>;
+};
+
+export type LegendQuantileProps<Scale extends AnyQuantileScale> = LegendProps<Scale> & FactoryProps;
 
-function labelFormatterFactoryFactory<Output>({
+function labelFormatterFactoryFactory<Scale extends AnyQuantileScale>({
   labelDelimiter,
-}: Pick<LegendQuantileProps<Output>, 'labelDelimiter'>): LabelFormatterFactory<
-  number,
-  Output,
-  ScaleQuantile<number, Output>
-> {
-  return ({ scale, labelFormat }) => (datum: number, index: number) => {
+}: FactoryProps): LabelFormatterFactory<Scale> {
+  return ({ scale, labelFormat }) => (datum, index) => {
     const [x0, x1] = scale.invertExtent(scale(datum));
     return {
       extent: [x0, x1],
@@ -29,21 +29,21 @@ function labelFormatterFactoryFactory<Output>({
 }
 
 /** A Quantile scale takes a number input and returns an Output. */
-export default function Quantile<Output>({
+export default function Quantile<Scale extends AnyQuantileScale>({
   domain: inputDomain,
   scale,
-  labelFormat = x => x,
+  labelFormat = identity,
   labelTransform: inputLabelTransform,
   labelDelimiter = '-',
   ...restProps
-}: LegendQuantileProps<Output>) {
+}: LegendQuantileProps<Scale>) {
   // transform range into input values because it may contain more elements
   const domain = inputDomain || scale.range().map(output => scale.invertExtent(output)[0]);
   const labelTransform =
-    inputLabelTransform || labelFormatterFactoryFactory<Output>({ labelDelimiter });
+    inputLabelTransform || labelFormatterFactoryFactory<Scale>({ labelDelimiter });
 
   return (
-    <Legend<number, Output, ScaleQuantile<number, Output>>
+    <Legend<Scale>
       scale={scale}
       domain={domain}
       labelFormat={labelFormat}
diff --git a/packages/vx-legend/src/legends/Size.tsx b/packages/vx-legend/src/legends/Size.tsx
index 8cf8581b3..c28e649c7 100644
--- a/packages/vx-legend/src/legends/Size.tsx
+++ b/packages/vx-legend/src/legends/Size.tsx
@@ -1,43 +1,29 @@
 import React from 'react';
+import { D3Scale } from '@vx/scale';
 import Legend, { LegendProps } from './Legend';
-import { ScaleType } from '../types';
 import labelTransformFactory from '../util/labelTransformFactory';
+import defaultDomain from '../util/defaultDomain';
+import identity from '../util/identity';
 
-export type LegendSizeProps<Datum> = {
-  steps?: number;
-} & LegendProps<Datum, number, ScaleType<Datum, number>>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnySizeScale = D3Scale<number, any, any>;
 
-function defaultDomain<Datum>({
-  steps,
-  scale,
-}: {
-  steps: number;
-  scale: ScaleType<Datum, number>;
-}) {
-  const domain = scale.domain();
-  const start = domain[0];
-  const end = domain[domain.length - 1];
-  if (typeof start === 'number' && typeof end === 'number') {
-    const step = (end - start) / (steps - 1);
-    return new Array(steps).fill(1).reduce((acc, cur, i) => {
-      acc.push(start + i * step);
-      return acc;
-    }, []);
-  }
-  return [];
-}
+export type LegendSizeProps<Scale extends AnySizeScale> = {
+  steps?: number;
+} & LegendProps<Scale>;
 
-export default function Size<Datum>({
+export default function Size<Scale extends AnySizeScale>({
   scale,
   domain: inputDomain,
   steps = 5,
-  labelFormat = x => x,
+  labelFormat = identity,
   labelTransform = labelTransformFactory,
   ...restProps
-}: LegendSizeProps<Datum>) {
+}: LegendSizeProps<Scale>) {
   const domain = inputDomain || defaultDomain({ steps, scale });
+
   return (
-    <Legend<Datum, number, ScaleType<Datum, number>>
+    <Legend<Scale>
       scale={scale}
       domain={domain}
       labelFormat={labelFormat}
diff --git a/packages/vx-legend/src/legends/Threshold.tsx b/packages/vx-legend/src/legends/Threshold.tsx
index 2d88564ae..e73632359 100644
--- a/packages/vx-legend/src/legends/Threshold.tsx
+++ b/packages/vx-legend/src/legends/Threshold.tsx
@@ -1,35 +1,39 @@
 import React from 'react';
+import { PickD3Scale, ScaleInput } from '@vx/scale';
 import Legend, { LegendProps } from './Legend';
-import { StringNumberDate, ScaleThreshold, LabelFormatterFactory } from '../types';
+import { LabelFormatterFactory } from '../types';
+import identity from '../util/identity';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyThresholdScale = PickD3Scale<'threshold', any, any, any>;
 
 const formatZero = (label: unknown) => (label === 0 ? '0' : label || '');
 
-export type LegendThresholdProps<Datum extends StringNumberDate, Output> = LegendProps<
-  Datum,
-  Output,
-  ScaleThreshold<Datum, Output>
-> & {
+type TransformProps = {
   labelDelimiter?: string;
   labelLower?: string;
   labelUpper?: string;
-  labelTransform?: LabelFormatterFactory<Datum, Output, ScaleThreshold<Datum, Output>>;
 };
 
+export type LegendThresholdProps<Scale extends AnyThresholdScale> = LegendProps<Scale> &
+  TransformProps & {
+    labelTransform?: LabelFormatterFactory<Scale>;
+  };
+
 /** Default transform implicitly assumes that Datum is of type number. */
-function defaultTransform<Datum extends StringNumberDate, Output>({
+function defaultTransform<Scale extends AnyThresholdScale>({
   labelDelimiter,
   labelLower,
   labelUpper,
-}: Pick<
-  LegendThresholdProps<Datum, Output>,
-  'labelDelimiter' | 'labelLower' | 'labelUpper'
->): LabelFormatterFactory<Datum, Output, ScaleThreshold<Datum, Output>> {
+}: TransformProps): LabelFormatterFactory<Scale> {
   return ({ scale, labelFormat }) => {
     const scaleRange = scale.range();
     const scaleDomain = scale.domain();
 
+    type Datum = ScaleInput<Scale>;
+
     return (d, i) => {
-      const [d0, d1]: [Datum | undefined, Datum | undefined] =
+      const [d0, d1] =
         scaleRange.length >= i ? scale.invertExtent(scaleRange[i]) : [undefined, undefined];
 
       let delimiter = ` ${labelDelimiter} `;
@@ -48,13 +52,13 @@ function defaultTransform<Datum extends StringNumberDate, Output>({
       } else if (typeof d0 === 'number' && d1 == null) {
         // upper threshold e.g., [number, undefined]
         delimiter = labelUpper || delimiter;
-        value = d0 + (scaleDomain[1] as number); // x0,x1 are from the domain, so the domain is numeric if d0 is
+        value = d0 + scaleDomain[1]; // x0,x1 are from the domain, so the domain is numeric if d0 is
         text = `${delimiter}${formatZero(labelFormat(d0, i))}`;
       }
 
       return {
         extent: [d0, d1],
-        value: scale((value as Datum) || d),
+        value: scale(value || d),
         text,
         datum: d,
         index: i,
@@ -63,33 +67,32 @@ function defaultTransform<Datum extends StringNumberDate, Output>({
   };
 }
 
-export default function Threshold<Datum extends StringNumberDate, Output>({
+export default function Threshold<Scale extends AnyThresholdScale>({
   scale,
   domain: inputDomain,
-  labelFormat = (d: Datum) => d,
+  labelFormat = identity,
   labelTransform: inputLabelTransform,
   labelDelimiter = 'to',
   labelLower = 'Less than ',
   labelUpper = 'More than ',
   ...restProps
-}: LegendThresholdProps<Datum, Output>) {
+}: LegendThresholdProps<Scale>) {
   // d3 docs specify that for n values in a domain, there should be n+1 values in the range
   // https://github.com/d3/d3-scale#threshold_domain
   // therefore if a domain is not specified we transform the range into input values
   // because it should contain more elements
-  const domain =
-    inputDomain || (scale.range().map(output => scale.invertExtent(output)[0]) as Datum[]);
+  const domain = inputDomain || scale.range().map(output => scale.invertExtent(output)[0]);
 
   const labelTransform =
     inputLabelTransform ||
-    defaultTransform<Datum, Output>({
+    defaultTransform<Scale>({
       labelDelimiter,
       labelLower,
       labelUpper,
     });
 
   return (
-    <Legend<Datum, Output, ScaleThreshold<Datum, Output>>
+    <Legend<Scale>
       scale={scale}
       domain={domain}
       labelFormat={labelFormat}
diff --git a/packages/vx-legend/src/types/index.ts b/packages/vx-legend/src/types/index.ts
index 3cbe21db3..5301b1d5c 100644
--- a/packages/vx-legend/src/types/index.ts
+++ b/packages/vx-legend/src/types/index.ts
@@ -1,35 +1,9 @@
-// eslint doesn't know about @types/d3-scale
-// eslint-disable-next-line import/no-extraneous-dependencies
-import * as d3Scale from 'd3-scale';
+import { AnyD3Scale, ScaleInput } from '@vx/scale';
 
-export type StringNumberDate = string | number | Date;
-
-export type ScaleBand<Input, _ImplicitStringOutput> = d3Scale.ScaleBand<Input>;
-export type ScaleLinear<_ImplicitNumberInput, Output> = d3Scale.ScaleLinear<Output, Output>;
-export type ScaleOrdinal<Input, Output> = d3Scale.ScaleOrdinal<Input, Output>;
-export type ScaleQuantile<_ImplicitNumberInput, Output> = d3Scale.ScaleQuantile<Output>;
-export type ScaleThreshold<Input extends StringNumberDate, Output> = d3Scale.ScaleThreshold<
-  Input,
-  Output
->;
-
-export type ScaleType<Input, Output> = Input extends StringNumberDate
-  ?
-      | ScaleThreshold<Input, Output> // StringNumberDate needed for ScaleThreshold only
-      | ScaleLinear<Input, Output>
-      | ScaleOrdinal<Input, Output>
-      | ScaleBand<Input, Output>
-      | ScaleQuantile<Input, Output>
-  :
-      | ScaleLinear<Input, Output>
-      | ScaleOrdinal<Input, Output>
-      | ScaleBand<Input, Output>
-      | ScaleQuantile<Input, Output>;
-
-export type LabelFormatterFactory<Datum, Output, Scale = ScaleType<Datum, Output>> = (args: {
+export type LabelFormatterFactory<Scale extends AnyD3Scale> = (args: {
   scale: Scale;
-  labelFormat: LabelFormatter<Datum>;
-}) => ItemTransformer<Datum, Output>;
+  labelFormat: LabelFormatter<ScaleInput<Scale>>;
+}) => ItemTransformer<ScaleInput<Scale>, ReturnType<Scale>>;
 
 export type LabelFormatter<Datum> = (
   item: Datum,
diff --git a/packages/vx-legend/src/util/defaultDomain.ts b/packages/vx-legend/src/util/defaultDomain.ts
new file mode 100644
index 000000000..bb2ac5be0
--- /dev/null
+++ b/packages/vx-legend/src/util/defaultDomain.ts
@@ -0,0 +1,21 @@
+import { D3Scale } from '@vx/scale';
+
+export default function defaultDomain<Scale extends D3Scale<number>>({
+  steps = 5,
+  scale,
+}: {
+  steps: number;
+  scale: Scale;
+}) {
+  const domain = scale.domain();
+  const start = domain[0];
+  const end = domain[domain.length - 1];
+  if (typeof start === 'number' && typeof end === 'number') {
+    const step = (end - start) / (steps - 1);
+    return new Array(steps).fill(1).reduce((acc, cur, i) => {
+      acc.push(start + i * step);
+      return acc;
+    }, []);
+  }
+  return [];
+}
diff --git a/packages/vx-legend/src/util/identity.ts b/packages/vx-legend/src/util/identity.ts
new file mode 100644
index 000000000..5538f4717
--- /dev/null
+++ b/packages/vx-legend/src/util/identity.ts
@@ -0,0 +1,3 @@
+export default function identity<T>(x: T) {
+  return x;
+}
diff --git a/packages/vx-legend/src/util/labelTransformFactory.ts b/packages/vx-legend/src/util/labelTransformFactory.ts
index 199f747ba..3579344ed 100644
--- a/packages/vx-legend/src/util/labelTransformFactory.ts
+++ b/packages/vx-legend/src/util/labelTransformFactory.ts
@@ -1,13 +1,14 @@
-import { LabelFormatter, ScaleType, ItemTransformer } from '../types';
+import { LabelFormatter, ItemTransformer } from '../types';
+import { AnyD3Scale, ScaleInput } from '../../../vx-scale/lib';
 
 /** Returns a function which takes a Datum and index as input, and returns a formatted label object. */
-export default function labelTransformFactory<Datum, Output, Scale = ScaleType<Datum, Output>>({
+export default function labelTransformFactory<Scale extends AnyD3Scale>({
   scale,
   labelFormat,
 }: {
   scale: Scale;
-  labelFormat: LabelFormatter<Datum>;
-}): ItemTransformer<Datum, Output> {
+  labelFormat: LabelFormatter<ScaleInput<Scale>>;
+}): ItemTransformer<ScaleInput<Scale>, ReturnType<Scale>> {
   return (d, i) => ({
     datum: d,
     index: i,
diff --git a/packages/vx-legend/test/scales.test.tsx b/packages/vx-legend/test/scales.test.tsx
index 374f2691a..539f0230c 100644
--- a/packages/vx-legend/test/scales.test.tsx
+++ b/packages/vx-legend/test/scales.test.tsx
@@ -10,7 +10,6 @@ import {
   LegendThreshold,
   LegendQuantile,
 } from '../src';
-import { ScaleBand, ScaleOrdinal, ScaleThreshold, ScaleQuantile } from '../src/types';
 
 describe('Legend scales', () => {
   it('should render with scaleLinear', () => {
@@ -20,7 +19,7 @@ describe('Legend scales', () => {
     });
 
     expect(() => shallow(<LegendLinear scale={linearScale} />)).not.toThrow();
-    expect(() => shallow(<LegendSize<number> scale={linearScale} />)).not.toThrow();
+    expect(() => shallow(<LegendSize scale={linearScale} />)).not.toThrow();
     expect(() => shallow(<Legend scale={linearScale} />)).not.toThrow();
   });
 
@@ -31,9 +30,7 @@ describe('Legend scales', () => {
     });
 
     expect(() => shallow(<LegendOrdinal scale={ordinalScale} />)).not.toThrow();
-    expect(() =>
-      shallow(<Legend<string, string, ScaleOrdinal<string, string>> scale={ordinalScale} />),
-    ).not.toThrow();
+    expect(() => shallow(<Legend scale={ordinalScale} />)).not.toThrow();
   });
 
   it('should render with scaleBand', () => {
@@ -42,9 +39,7 @@ describe('Legend scales', () => {
       range: [1, 10],
     });
 
-    expect(() =>
-      shallow(<Legend<string, number, ScaleBand<string, number>> scale={bandScale} />),
-    ).not.toThrow();
+    expect(() => shallow(<Legend scale={bandScale} />)).not.toThrow();
   });
 
   it('should render with scaleThreshold', () => {
@@ -54,9 +49,7 @@ describe('Legend scales', () => {
     });
 
     expect(() => shallow(<LegendThreshold scale={thresholdScale} />)).not.toThrow();
-    expect(() =>
-      shallow(<Legend<number, string, ScaleThreshold<number, string>> scale={thresholdScale} />),
-    ).not.toThrow();
+    expect(() => shallow(<Legend scale={thresholdScale} />)).not.toThrow();
   });
 
   it('should render with scaleQuantile', () => {
@@ -66,8 +59,6 @@ describe('Legend scales', () => {
     });
 
     expect(() => shallow(<LegendQuantile scale={quantileScale} />)).not.toThrow();
-    expect(() =>
-      shallow(<Legend<number, string, ScaleQuantile<number, string>> scale={quantileScale} />),
-    ).not.toThrow();
+    expect(() => shallow(<Legend scale={quantileScale} />)).not.toThrow();
   });
 });