diff --git a/api/metric/number.go b/api/metric/number.go
index 50349cf69..1e04a0009 100644
--- a/api/metric/number.go
+++ b/api/metric/number.go
@@ -32,9 +32,6 @@ const (
 	Int64NumberKind NumberKind = iota
 	// Float64NumberKind means that the Number stores float64.
 	Float64NumberKind
-	// Uint64NumberKind means that the Number stores uint64.
-	// TODO: This can be removed, it's not used.
-	Uint64NumberKind
 )
 
 // Zero returns a zero value for a given NumberKind
@@ -44,8 +41,6 @@ func (k NumberKind) Zero() Number {
 		return NewInt64Number(0)
 	case Float64NumberKind:
 		return NewFloat64Number(0.)
-	case Uint64NumberKind:
-		return NewUint64Number(0)
 	default:
 		return Number(0)
 	}
@@ -59,8 +54,6 @@ func (k NumberKind) Minimum() Number {
 		return NewInt64Number(math.MinInt64)
 	case Float64NumberKind:
 		return NewFloat64Number(-1. * math.MaxFloat64)
-	case Uint64NumberKind:
-		return NewUint64Number(0)
 	default:
 		return Number(0)
 	}
@@ -74,8 +67,6 @@ func (k NumberKind) Maximum() Number {
 		return NewInt64Number(math.MaxInt64)
 	case Float64NumberKind:
 		return NewFloat64Number(math.MaxFloat64)
-	case Uint64NumberKind:
-		return NewUint64Number(math.MaxUint64)
 	default:
 		return Number(0)
 	}
@@ -103,11 +94,6 @@ func NewFloat64Number(f float64) Number {
 	return NewNumberFromRaw(internal.Float64ToRaw(f))
 }
 
-// NewInt64Number creates an integral Number.
-func NewUint64Number(u uint64) Number {
-	return NewNumberFromRaw(internal.Uint64ToRaw(u))
-}
-
 // NewNumberSignChange returns a number with the same magnitude and
 // the opposite sign.  `kind` must describe the kind of number in `nn`.
 //
@@ -147,12 +133,6 @@ func (n *Number) AsFloat64() float64 {
 	return internal.RawToFloat64(n.AsRaw())
 }
 
-// AsUint64 assumes that the value contains an uint64 and returns it
-// as such.
-func (n *Number) AsUint64() uint64 {
-	return internal.RawToUint64(n.AsRaw())
-}
-
 // - as x atomic
 
 // AsNumberAtomic gets the Number atomically.
@@ -178,12 +158,6 @@ func (n *Number) AsFloat64Atomic() float64 {
 	return internal.RawToFloat64(n.AsRawAtomic())
 }
 
-// AsUint64Atomic assumes that the number contains a uint64 and
-// returns it as such atomically.
-func (n *Number) AsUint64Atomic() uint64 {
-	return atomic.LoadUint64(n.AsUint64Ptr())
-}
-
 // - as x ptr
 
 // AsRawPtr gets the pointer to the raw, uninterpreted raw
@@ -204,12 +178,6 @@ func (n *Number) AsFloat64Ptr() *float64 {
 	return internal.RawPtrToFloat64Ptr(n.AsRawPtr())
 }
 
-// AsUint64Ptr assumes that the number contains a uint64 and returns a
-// pointer to it.
-func (n *Number) AsUint64Ptr() *uint64 {
-	return internal.RawPtrToUint64Ptr(n.AsRawPtr())
-}
-
 // - coerce
 
 // CoerceToInt64 casts the number to int64. May result in
@@ -220,8 +188,6 @@ func (n *Number) CoerceToInt64(kind NumberKind) int64 {
 		return n.AsInt64()
 	case Float64NumberKind:
 		return int64(n.AsFloat64())
-	case Uint64NumberKind:
-		return int64(n.AsUint64())
 	default:
 		// you get what you deserve
 		return 0
@@ -236,24 +202,6 @@ func (n *Number) CoerceToFloat64(kind NumberKind) float64 {
 		return float64(n.AsInt64())
 	case Float64NumberKind:
 		return n.AsFloat64()
-	case Uint64NumberKind:
-		return float64(n.AsUint64())
-	default:
-		// you get what you deserve
-		return 0
-	}
-}
-
-// CoerceToUint64 casts the number to uint64. May result in
-// data/precision loss.
-func (n *Number) CoerceToUint64(kind NumberKind) uint64 {
-	switch kind {
-	case Int64NumberKind:
-		return uint64(n.AsInt64())
-	case Float64NumberKind:
-		return uint64(n.AsFloat64())
-	case Uint64NumberKind:
-		return n.AsUint64()
 	default:
 		// you get what you deserve
 		return 0
@@ -286,12 +234,6 @@ func (n *Number) SetFloat64(f float64) {
 	*n.AsFloat64Ptr() = f
 }
 
-// SetUint64 assumes that the number contains a uint64 and sets it to
-// the passed value.
-func (n *Number) SetUint64(u uint64) {
-	*n.AsUint64Ptr() = u
-}
-
 // - set atomic
 
 // SetNumberAtomic sets the number to the passed number
@@ -319,12 +261,6 @@ func (n *Number) SetFloat64Atomic(f float64) {
 	atomic.StoreUint64(n.AsRawPtr(), internal.Float64ToRaw(f))
 }
 
-// SetUint64Atomic assumes that the number contains a uint64 and sets
-// it to the passed value atomically.
-func (n *Number) SetUint64Atomic(u uint64) {
-	atomic.StoreUint64(n.AsUint64Ptr(), u)
-}
-
 // - swap
 
 // SwapNumber sets the number to the passed number and returns the old
@@ -361,14 +297,6 @@ func (n *Number) SwapFloat64(f float64) float64 {
 	return old
 }
 
-// SwapUint64 assumes that the number contains an uint64, sets it to
-// the passed value and returns the old uint64 value.
-func (n *Number) SwapUint64(u uint64) uint64 {
-	old := n.AsUint64()
-	n.SetUint64(u)
-	return old
-}
-
 // - swap atomic
 
 // SwapNumberAtomic sets the number to the passed number and returns
@@ -398,12 +326,6 @@ func (n *Number) SwapFloat64Atomic(f float64) float64 {
 	return internal.RawToFloat64(atomic.SwapUint64(n.AsRawPtr(), internal.Float64ToRaw(f)))
 }
 
-// SwapUint64Atomic assumes that the number contains an uint64, sets
-// it to the passed value and returns the old uint64 value atomically.
-func (n *Number) SwapUint64Atomic(u uint64) uint64 {
-	return atomic.SwapUint64(n.AsUint64Ptr(), u)
-}
-
 // - add
 
 // AddNumber assumes that this and the passed number are of the passed
@@ -414,8 +336,6 @@ func (n *Number) AddNumber(kind NumberKind, nn Number) {
 		n.AddInt64(nn.AsInt64())
 	case Float64NumberKind:
 		n.AddFloat64(nn.AsFloat64())
-	case Uint64NumberKind:
-		n.AddUint64(nn.AsUint64())
 	}
 }
 
@@ -437,12 +357,6 @@ func (n *Number) AddFloat64(f float64) {
 	*n.AsFloat64Ptr() += f
 }
 
-// AddUint64 assumes that the number contains a uint64 and adds the
-// passed uint64 to it.
-func (n *Number) AddUint64(u uint64) {
-	*n.AsUint64Ptr() += u
-}
-
 // - add atomic
 
 // AddNumberAtomic assumes that this and the passed number are of the
@@ -453,8 +367,6 @@ func (n *Number) AddNumberAtomic(kind NumberKind, nn Number) {
 		n.AddInt64Atomic(nn.AsInt64())
 	case Float64NumberKind:
 		n.AddFloat64Atomic(nn.AsFloat64())
-	case Uint64NumberKind:
-		n.AddUint64Atomic(nn.AsUint64())
 	}
 }
 
@@ -482,12 +394,6 @@ func (n *Number) AddFloat64Atomic(f float64) {
 	}
 }
 
-// AddUint64Atomic assumes that the number contains a uint64 and
-// atomically adds the passed uint64 to it.
-func (n *Number) AddUint64Atomic(u uint64) {
-	atomic.AddUint64(n.AsUint64Ptr(), u)
-}
-
 // - compare and swap (atomic only)
 
 // CompareAndSwapNumber does the atomic CAS operation on this
@@ -516,12 +422,6 @@ func (n *Number) CompareAndSwapFloat64(of, nf float64) bool {
 	return atomic.CompareAndSwapUint64(n.AsRawPtr(), internal.Float64ToRaw(of), internal.Float64ToRaw(nf))
 }
 
-// CompareAndSwapUint64 assumes that this number contains a uint64 and
-// does the atomic CAS operation on it.
-func (n *Number) CompareAndSwapUint64(ou, nu uint64) bool {
-	return atomic.CompareAndSwapUint64(n.AsUint64Ptr(), ou, nu)
-}
-
 // - compare
 
 // CompareNumber compares two Numbers given their kind.  Both numbers
@@ -535,8 +435,6 @@ func (n *Number) CompareNumber(kind NumberKind, nn Number) int {
 		return n.CompareInt64(nn.AsInt64())
 	case Float64NumberKind:
 		return n.CompareFloat64(nn.AsFloat64())
-	case Uint64NumberKind:
-		return n.CompareUint64(nn.AsUint64())
 	default:
 		// you get what you deserve
 		return 0
@@ -581,21 +479,6 @@ func (n *Number) CompareFloat64(f float64) int {
 	return 0
 }
 
-// CompareUint64 assumes that the Number contains an uint64 and performs
-// a comparison between the value and the other value. It returns the
-// typical result of the compare function: -1 if the value is less
-// than the other, 0 if both are equal, 1 if the value is greater than
-// the other.
-func (n *Number) CompareUint64(u uint64) int {
-	this := n.AsUint64()
-	if this < u {
-		return -1
-	} else if this > u {
-		return 1
-	}
-	return 0
-}
-
 // - relations to zero
 
 // IsPositive returns true if the actual value is greater than zero.
@@ -624,8 +507,6 @@ func (n *Number) Emit(kind NumberKind) string {
 		return fmt.Sprintf("%d", n.AsInt64())
 	case Float64NumberKind:
 		return fmt.Sprintf("%f", n.AsFloat64())
-	case Uint64NumberKind:
-		return fmt.Sprintf("%d", n.AsUint64())
 	default:
 		return ""
 	}
@@ -639,8 +520,6 @@ func (n *Number) AsInterface(kind NumberKind) interface{} {
 		return n.AsInt64()
 	case Float64NumberKind:
 		return n.AsFloat64()
-	case Uint64NumberKind:
-		return n.AsUint64()
 	default:
 		return math.NaN()
 	}
@@ -654,8 +533,6 @@ func (n *Number) compareWithZero(kind NumberKind) int {
 		return n.CompareInt64(0)
 	case Float64NumberKind:
 		return n.CompareFloat64(0.)
-	case Uint64NumberKind:
-		return n.CompareUint64(0)
 	default:
 		// you get what you deserve
 		return 0
diff --git a/api/metric/number_test.go b/api/metric/number_test.go
index 80ca6c426..6a3f2abd1 100644
--- a/api/metric/number_test.go
+++ b/api/metric/number_test.go
@@ -156,9 +156,8 @@ func TestNumberZero(t *testing.T) {
 	zero := Number(0)
 	zerof := NewFloat64Number(0)
 	zeroi := NewInt64Number(0)
-	zerou := NewUint64Number(0)
 
-	if zero != zerof || zero != zeroi || zero != zerou {
+	if zero != zerof || zero != zeroi {
 		t.Errorf("Invalid zero representations")
 	}
 }
@@ -166,10 +165,8 @@ func TestNumberZero(t *testing.T) {
 func TestNumberAsInterface(t *testing.T) {
 	i64 := NewInt64Number(10)
 	f64 := NewFloat64Number(11.11)
-	u64 := NewUint64Number(100)
 	require.Equal(t, int64(10), (&i64).AsInterface(Int64NumberKind).(int64))
 	require.Equal(t, 11.11, (&f64).AsInterface(Float64NumberKind).(float64))
-	require.Equal(t, uint64(100), (&u64).AsInterface(Uint64NumberKind).(uint64))
 }
 
 func TestNumberSignChange(t *testing.T) {
diff --git a/api/metric/numberkind_string.go b/api/metric/numberkind_string.go
index 213783785..e99a8745e 100644
--- a/api/metric/numberkind_string.go
+++ b/api/metric/numberkind_string.go
@@ -10,12 +10,11 @@ func _() {
 	var x [1]struct{}
 	_ = x[Int64NumberKind-0]
 	_ = x[Float64NumberKind-1]
-	_ = x[Uint64NumberKind-2]
 }
 
-const _NumberKind_name = "Int64NumberKindFloat64NumberKindUint64NumberKind"
+const _NumberKind_name = "Int64NumberKindFloat64NumberKind"
 
-var _NumberKind_index = [...]uint8{0, 15, 32, 48}
+var _NumberKind_index = [...]uint8{0, 15, 32}
 
 func (i NumberKind) String() string {
 	if i < 0 || i >= NumberKind(len(_NumberKind_index)-1) {
diff --git a/exporters/otlp/internal/transform/metric.go b/exporters/otlp/internal/transform/metric.go
index 18d0bf06a..04f146541 100644
--- a/exporters/otlp/internal/transform/metric.go
+++ b/exporters/otlp/internal/transform/metric.go
@@ -263,7 +263,7 @@ func sum(record export.Record, a aggregation.Sum) (*metricpb.Metric, error) {
 	}
 
 	switch n := desc.NumberKind(); n {
-	case metric.Int64NumberKind, metric.Uint64NumberKind:
+	case metric.Int64NumberKind:
 		m.MetricDescriptor.Type = metricpb.MetricDescriptor_COUNTER_INT64
 		m.Int64DataPoints = []*metricpb.Int64DataPoint{
 			{
diff --git a/exporters/otlp/otlp_metric_test.go b/exporters/otlp/otlp_metric_test.go
index 99d24a10b..280e7ae20 100644
--- a/exporters/otlp/otlp_metric_test.go
+++ b/exporters/otlp/otlp_metric_test.go
@@ -283,8 +283,6 @@ func TestValuerecorderMetricGroupingExport(t *testing.T) {
 	}
 	runMetricExportTests(t, []record{r, r}, expected)
 	//changing the number kind should make no difference.
-	r.nKind = metric.Uint64NumberKind
-	runMetricExportTests(t, []record{r, r}, expected)
 	r.nKind = metric.Float64NumberKind
 	runMetricExportTests(t, []record{r, r}, expected)
 }
@@ -330,60 +328,6 @@ func TestCountInt64MetricGroupingExport(t *testing.T) {
 	)
 }
 
-func TestCountUint64MetricGroupingExport(t *testing.T) {
-	r := record{
-		"uint64-count",
-		metric.CounterKind,
-		metric.Uint64NumberKind,
-		nil,
-		nil,
-		append(baseKeyValues, cpuKey.Int(1)),
-	}
-	runMetricExportTests(
-		t,
-		[]record{r, r},
-		[]metricpb.ResourceMetrics{
-			{
-				Resource: nil,
-				InstrumentationLibraryMetrics: []*metricpb.InstrumentationLibraryMetrics{
-					{
-						Metrics: []*metricpb.Metric{
-							{
-								MetricDescriptor: &metricpb.MetricDescriptor{
-									Name: "uint64-count",
-									Type: metricpb.MetricDescriptor_COUNTER_INT64,
-									Labels: []*commonpb.StringKeyValue{
-										{
-											Key:   "CPU",
-											Value: "1",
-										},
-										{
-											Key:   "host",
-											Value: "test.com",
-										},
-									},
-								},
-								Int64DataPoints: []*metricpb.Int64DataPoint{
-									{
-										Value:             11,
-										StartTimeUnixNano: startTime(),
-										TimeUnixNano:      pointTime(),
-									},
-									{
-										Value:             11,
-										StartTimeUnixNano: startTime(),
-										TimeUnixNano:      pointTime(),
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-	)
-}
-
 func TestCountFloat64MetricGroupingExport(t *testing.T) {
 	r := record{
 		"float64-count",
@@ -729,9 +673,6 @@ func runMetricExportTest(t *testing.T, exp *Exporter, rs []record, expected []me
 
 		ctx := context.Background()
 		switch r.nKind {
-		case metric.Uint64NumberKind:
-			require.NoError(t, agg.Update(ctx, metric.NewUint64Number(1), &desc))
-			require.NoError(t, agg.Update(ctx, metric.NewUint64Number(10), &desc))
 		case metric.Int64NumberKind:
 			require.NoError(t, agg.Update(ctx, metric.NewInt64Number(1), &desc))
 			require.NoError(t, agg.Update(ctx, metric.NewInt64Number(10), &desc))
diff --git a/sdk/metric/aggregator/histogram/histogram.go b/sdk/metric/aggregator/histogram/histogram.go
index abad71aa1..185b14a86 100644
--- a/sdk/metric/aggregator/histogram/histogram.go
+++ b/sdk/metric/aggregator/histogram/histogram.go
@@ -45,8 +45,8 @@ type (
 	// the less than equal bucket count for the pre-determined boundaries.
 	state struct {
 		bucketCounts []float64
-		count        metric.Number
 		sum          metric.Number
+		count        int64
 	}
 )
 
@@ -100,7 +100,7 @@ func (c *Aggregator) Sum() (metric.Number, error) {
 
 // Count returns the number of values in the checkpoint.
 func (c *Aggregator) Count() (int64, error) {
-	return int64(c.state.count), nil
+	return c.state.count, nil
 }
 
 // Histogram returns the count of events in pre-determined buckets.
@@ -160,7 +160,7 @@ func (c *Aggregator) Update(_ context.Context, number metric.Number, desc *metri
 	c.lock.Lock()
 	defer c.lock.Unlock()
 
-	c.state.count.AddInt64(1)
+	c.state.count++
 	c.state.sum.AddNumber(kind, number)
 	c.state.bucketCounts[bucketID]++
 
@@ -175,7 +175,7 @@ func (c *Aggregator) Merge(oa export.Aggregator, desc *metric.Descriptor) error
 	}
 
 	c.state.sum.AddNumber(desc.NumberKind(), o.state.sum)
-	c.state.count.AddNumber(metric.Uint64NumberKind, o.state.count)
+	c.state.count += o.state.count
 
 	for i := 0; i < len(c.state.bucketCounts); i++ {
 		c.state.bucketCounts[i] += o.state.bucketCounts[i]