diff --git a/go/otel/otel.stef b/go/otel/otel.stef
index 1dbebe84..6e465c07 100755
--- a/go/otel/otel.stef
+++ b/go/otel/otel.stef
@@ -63,13 +63,21 @@ struct Metric dict(Metric) {
   Name string dict(MetricName)
   Description string dict(MetricDescription)
   Unit string dict(MetricUnit)
-  Type uint64
+  Type MetricType
   Metadata Attributes
   HistogramBounds []float64
   AggregationTemporality uint64
   Monotonic bool
 }
 
+enum MetricType {
+	Gauge = 0
+	Sum = 1
+	Histogram = 2
+	ExpHistogram = 3
+	Summary = 4
+}
+
 struct Metrics root {
   Envelope Envelope
   Metric Metric
diff --git a/go/otel/oteltef/metric.go b/go/otel/oteltef/metric.go
index fe4d42e7..864807d6 100644
--- a/go/otel/oteltef/metric.go
+++ b/go/otel/oteltef/metric.go
@@ -133,14 +133,14 @@ func (s *Metric) IsUnitModified() bool {
 	return s.modifiedFields.mask&fieldModifiedMetricUnit != 0
 }
 
-func (s *Metric) Type() uint64 {
-	return s.type_
+func (s *Metric) Type() MetricType {
+	return MetricType(s.type_)
 }
 
 // SetType sets the value of Type field.
-func (s *Metric) SetType(v uint64) {
-	if !pkg.Uint64Equal(s.type_, v) {
-		s.type_ = v
+func (s *Metric) SetType(v MetricType) {
+	if !pkg.Uint64Equal(s.type_, uint64(v)) {
+		s.type_ = uint64(v)
 		s.markTypeModified()
 	}
 }
@@ -284,7 +284,7 @@ func copyMetric(dst *Metric, src *Metric) {
 	dst.SetName(src.name)
 	dst.SetDescription(src.description)
 	dst.SetUnit(src.unit)
-	dst.SetType(src.type_)
+	dst.SetType(MetricType(src.type_))
 	copyAttributes(&dst.metadata, &src.metadata)
 	copyFloat64Array(&dst.histogramBounds, &src.histogramBounds)
 	dst.SetAggregationTemporality(src.aggregationTemporality)
@@ -320,7 +320,7 @@ func (s *Metric) mutateRandom(random *rand.Rand) {
 		s.SetUnit(pkg.StringRandom(random))
 	}
 	if random.IntN(fieldCount) == 0 {
-		s.SetType(pkg.Uint64Random(random))
+		s.SetType(MetricType(pkg.Uint64Random(random)))
 	}
 	if random.IntN(fieldCount) == 0 {
 		s.metadata.mutateRandom(random)
diff --git a/go/otel/oteltef/metrictype.go b/go/otel/oteltef/metrictype.go
new file mode 100644
index 00000000..81c5359a
--- /dev/null
+++ b/go/otel/oteltef/metrictype.go
@@ -0,0 +1,12 @@
+// Code generated by stefgen. DO NOT EDIT.
+package oteltef
+
+type MetricType uint64
+
+const (
+	MetricTypeGauge        MetricType = 0
+	MetricTypeSum          MetricType = 1
+	MetricTypeHistogram    MetricType = 2
+	MetricTypeExpHistogram MetricType = 3
+	MetricTypeSummary      MetricType = 4
+)
diff --git a/go/pdata/internal/otlptools/convert.go b/go/pdata/internal/otlptools/convert.go
index 858739e4..6ab30911 100644
--- a/go/pdata/internal/otlptools/convert.go
+++ b/go/pdata/internal/otlptools/convert.go
@@ -51,11 +51,11 @@ func MetricToOtlp(metric *oteltef.Metric, out pmetric.Metric) error {
 	}
 
 	switch oteltef.MetricType(metric.Type()) {
-	case oteltef.Gauge:
+	case oteltef.MetricTypeGauge:
 		out.SetEmptyGauge()
-	case oteltef.Sum:
+	case oteltef.MetricTypeSum:
 		out.SetEmptySum()
-	case oteltef.Histogram:
+	case oteltef.MetricTypeHistogram:
 		out.SetEmptyHistogram()
 	default:
 		panic("not implemented")
diff --git a/go/pdata/metrics/internal/basesteftotolp.go b/go/pdata/metrics/internal/basesteftotolp.go
index 388bf28a..82e415b6 100644
--- a/go/pdata/metrics/internal/basesteftotolp.go
+++ b/go/pdata/metrics/internal/basesteftotolp.go
@@ -79,14 +79,14 @@ func (s *BaseSTEFToOTLP) AppendOTLPPoint(
 		}
 		otlpAttrs.MoveTo(point.Attributes())
 		dstMetric.Sum().SetIsMonotonic(srcMetric.Monotonic())
-		dstMetric.Sum().SetAggregationTemporality(aggregationTemporalityToOtlp(oteltef.MetricFlags(srcMetric.AggregationTemporality())))
+		dstMetric.Sum().SetAggregationTemporality(aggregationTemporalityToOtlp(MetricFlags(srcMetric.AggregationTemporality())))
 	case pmetric.MetricTypeHistogram:
 		point := dstMetric.Histogram().DataPoints().AppendEmpty()
 		if err := s.convertHistogramPoint(srcMetric, srcPoint, point); err != nil {
 			return err
 		}
 		otlpAttrs.MoveTo(point.Attributes())
-		dstMetric.Histogram().SetAggregationTemporality(aggregationTemporalityToOtlp(oteltef.MetricFlags(srcMetric.AggregationTemporality())))
+		dstMetric.Histogram().SetAggregationTemporality(aggregationTemporalityToOtlp(MetricFlags(srcMetric.AggregationTemporality())))
 	default:
 		panic("not implemented")
 	}
@@ -94,13 +94,13 @@ func (s *BaseSTEFToOTLP) AppendOTLPPoint(
 	return nil
 }
 
-func aggregationTemporalityToOtlp(flags oteltef.MetricFlags) pmetric.AggregationTemporality {
-	switch flags & oteltef.MetricTemporalityMask {
-	case oteltef.MetricTemporalityDelta:
+func aggregationTemporalityToOtlp(flags MetricFlags) pmetric.AggregationTemporality {
+	switch flags & MetricTemporalityMask {
+	case MetricTemporalityDelta:
 		return pmetric.AggregationTemporalityDelta
-	case oteltef.MetricTemporalityCumulative:
+	case MetricTemporalityCumulative:
 		return pmetric.AggregationTemporalityCumulative
-	case oteltef.MetricTemporalityUnspecified:
+	case MetricTemporalityUnspecified:
 		return pmetric.AggregationTemporalityUnspecified
 	default:
 		panic("unexpected metric flags")
diff --git a/go/otel/oteltef/enums.go b/go/pdata/metrics/internal/metricflags.go
similarity index 52%
rename from go/otel/oteltef/enums.go
rename to go/pdata/metrics/internal/metricflags.go
index 00b984d7..e9fe524f 100644
--- a/go/otel/oteltef/enums.go
+++ b/go/pdata/metrics/internal/metricflags.go
@@ -1,15 +1,4 @@
-package oteltef
-
-type MetricType uint
-
-const (
-	Gauge MetricType = iota
-	Sum
-	Histogram
-	ExpHistogram
-	Summary
-	MetricTypeLimit
-)
+package internal
 
 // MetricFlags is a bitmask
 type MetricFlags uint
@@ -21,11 +10,3 @@ const (
 	MetricTemporalityDelta       MetricFlags = 0b010
 	MetricTemporalityCumulative  MetricFlags = 0b100
 )
-
-//type HistogramFieldPresenceMask int64
-//
-//const (
-//	HistogramHasSum = HistogramFieldPresenceMask(1 << iota)
-//	HistogramHasMin
-//	HistogramHasMax
-//)
diff --git a/go/pdata/metrics/otlp2sortedtree.go b/go/pdata/metrics/otlp2sortedtree.go
index 1b16689a..35904203 100644
--- a/go/pdata/metrics/otlp2sortedtree.go
+++ b/go/pdata/metrics/otlp2sortedtree.go
@@ -58,19 +58,19 @@ func (c *OtlpToSortedTree) FromOtlp(rms pmetric.ResourceMetricsSlice) (*sortedby
 	return sm, nil
 }
 
-func calcMetricFlags(monotonic bool, temporality pmetric.AggregationTemporality) oteltef.MetricFlags {
-	var flags oteltef.MetricFlags
+func calcMetricFlags(monotonic bool, temporality pmetric.AggregationTemporality) internal.MetricFlags {
+	var flags internal.MetricFlags
 	if monotonic {
-		flags |= oteltef.MetricMonotonic
+		flags |= internal.MetricMonotonic
 	}
 
 	switch temporality {
 	case pmetric.AggregationTemporalityDelta:
-		flags |= oteltef.MetricTemporalityDelta
+		flags |= internal.MetricTemporalityDelta
 	case pmetric.AggregationTemporalityCumulative:
-		flags |= oteltef.MetricTemporalityCumulative
+		flags |= internal.MetricTemporalityCumulative
 	case pmetric.AggregationTemporalityUnspecified:
-		flags |= oteltef.MetricTemporalityUnspecified
+		flags |= internal.MetricTemporalityUnspecified
 	default:
 		panic("Unknown temporality value")
 	}
@@ -83,7 +83,7 @@ func (c *OtlpToSortedTree) covertNumberDataPoints(
 	sms pmetric.ScopeMetrics,
 	metric pmetric.Metric,
 	srcPoints pmetric.NumberDataPointSlice,
-	flags oteltef.MetricFlags,
+	flags internal.MetricFlags,
 ) {
 	var metricType oteltef.MetricType
 	var byMetric *sortedbymetric.ByMetric
@@ -127,9 +127,9 @@ func (c *OtlpToSortedTree) covertNumberDataPoints(
 func calcNumericMetricType(metric pmetric.Metric) oteltef.MetricType {
 	switch metric.Type() {
 	case pmetric.MetricTypeGauge:
-		return oteltef.Gauge
+		return oteltef.MetricTypeGauge
 	case pmetric.MetricTypeSum:
-		return oteltef.Sum
+		return oteltef.MetricTypeSum
 	default:
 		log.Fatalf("Unsupported value type: %v", metric.Type())
 	}
@@ -153,7 +153,7 @@ func (c *OtlpToSortedTree) covertHistogramDataPoints(
 
 		c.recordCount++
 
-		byMetric = sm.ByMetric(metric, oteltef.Histogram, flags, srcPoint.ExplicitBounds().AsRaw())
+		byMetric = sm.ByMetric(metric, oteltef.MetricTypeHistogram, flags, srcPoint.ExplicitBounds().AsRaw())
 		byResource := byMetric.ByResource(rm.Resource(), rm.SchemaUrl())
 		byScope = byResource.ByScope(sms.Scope(), sms.SchemaUrl())
 		c.Otlp2tef.MapSorted(srcPoint.Attributes(), &c.TempAttrs)
diff --git a/go/pdata/metrics/otlp2stef.go b/go/pdata/metrics/otlp2stef.go
index 7ab17482..5cc450dd 100644
--- a/go/pdata/metrics/otlp2stef.go
+++ b/go/pdata/metrics/otlp2stef.go
@@ -14,14 +14,14 @@ type OtlpToSTEFUnsorted struct {
 	internal.BaseOTLPToSTEF
 }
 
-func convertTemporality(temporality pmetric.AggregationTemporality) oteltef.MetricFlags {
+func convertTemporality(temporality pmetric.AggregationTemporality) internal.MetricFlags {
 	switch temporality {
 	case pmetric.AggregationTemporalityCumulative:
-		return oteltef.MetricTemporalityCumulative
+		return internal.MetricTemporalityCumulative
 	case pmetric.AggregationTemporalityDelta:
-		return oteltef.MetricTemporalityDelta
+		return internal.MetricTemporalityDelta
 	case pmetric.AggregationTemporalityUnspecified:
-		return oteltef.MetricTemporalityUnspecified
+		return internal.MetricTemporalityUnspecified
 	default:
 		panic("unhandled default case")
 	}
@@ -30,11 +30,11 @@ func convertTemporality(temporality pmetric.AggregationTemporality) oteltef.Metr
 func metricType(typ pmetric.MetricType) oteltef.MetricType {
 	switch typ {
 	case pmetric.MetricTypeGauge:
-		return oteltef.Gauge
+		return oteltef.MetricTypeGauge
 	case pmetric.MetricTypeSum:
-		return oteltef.Sum
+		return oteltef.MetricTypeSum
 	case pmetric.MetricTypeHistogram:
-		return oteltef.Histogram
+		return oteltef.MetricTypeHistogram
 	default:
 		log.Fatalf("Unsupported value type: %v", typ)
 	}
@@ -50,7 +50,7 @@ func metric2metric(
 	dst.SetName(src.Name())
 	dst.SetDescription(src.Description())
 	dst.SetUnit(src.Unit())
-	dst.SetType(uint64(metricType(src.Type())))
+	dst.SetType(metricType(src.Type()))
 }
 
 func (d *OtlpToSTEFUnsorted) WriteMetrics(src pmetric.Metrics, writer *oteltef.MetricsWriter) error {
diff --git a/go/pdata/metrics/sortedbymetric/sortedmetrics.go b/go/pdata/metrics/sortedbymetric/sortedmetrics.go
index 80c1dd04..ffe924cc 100644
--- a/go/pdata/metrics/sortedbymetric/sortedmetrics.go
+++ b/go/pdata/metrics/sortedbymetric/sortedmetrics.go
@@ -8,6 +8,7 @@ import (
 	"go.opentelemetry.io/collector/pdata/pmetric"
 	"modernc.org/b/v2"
 
+	"github.com/splunk/stef/go/pdata/metrics/internal"
 	"github.com/splunk/stef/go/pkg"
 
 	"github.com/splunk/stef/go/otel/oteltef"
@@ -88,7 +89,7 @@ func (s *SortedTree) ToTef(writer *oteltef.MetricsWriter) error {
 }
 
 func (s *SortedTree) ByMetric(
-	metric pmetric.Metric, metricType oteltef.MetricType, flags oteltef.MetricFlags,
+	metric pmetric.Metric, metricType oteltef.MetricType, flags internal.MetricFlags,
 	histogramBounds []float64,
 ) *ByMetric {
 	metr := metric2metric(metric, metricType, flags, histogramBounds, &s.otlp2tef)
@@ -103,7 +104,7 @@ func (s *SortedTree) ByMetric(
 }
 
 func metric2metric(
-	metric pmetric.Metric, metricType oteltef.MetricType, flags oteltef.MetricFlags, histogramBounds []float64,
+	metric pmetric.Metric, metricType oteltef.MetricType, flags internal.MetricFlags, histogramBounds []float64,
 	otlp2tef *otlptools.Otlp2Stef,
 ) *oteltef.Metric {
 
@@ -112,11 +113,11 @@ func metric2metric(
 	dst.SetName(metric.Name())
 	dst.SetDescription(metric.Description())
 	dst.SetUnit(metric.Unit())
-	dst.SetType(uint64(metricType))
+	dst.SetType(metricType)
 	//dst.SetFlags(uint64(flags))
 	dst.HistogramBounds().CopyFromSlice(histogramBounds)
-	dst.SetMonotonic(flags&oteltef.MetricMonotonic != 0)
-	dst.SetAggregationTemporality(uint64(flags & oteltef.MetricTemporalityMask))
+	dst.SetMonotonic(flags&internal.MetricMonotonic != 0)
+	dst.SetAggregationTemporality(uint64(flags & internal.MetricTemporalityMask))
 
 	return &dst
 }
diff --git a/stefgen/generator/compileschema.go b/stefgen/generator/compileschema.go
index 7df09edd..5a8b1515 100644
--- a/stefgen/generator/compileschema.go
+++ b/stefgen/generator/compileschema.go
@@ -11,6 +11,7 @@ func compileSchema(src *schema.Schema) (*genSchema, error) {
 		PackageName: src.PackageName,
 		Structs:     map[string]*genStructDef{},
 		Multimaps:   map[string]*genMapDef{},
+		Enums:       map[string]*genEnumDef{},
 	}
 
 	for name, struc := range src.Structs {
@@ -21,6 +22,10 @@ func compileSchema(src *schema.Schema) (*genSchema, error) {
 		dst.Multimaps[name] = multimapWireToGen(multimap)
 	}
 
+	for name, enum := range src.Enums {
+		dst.Enums[name] = enumSchemaToGen(enum)
+	}
+
 	if err := dst.resolveRefs(); err != nil {
 		return nil, err
 	}
@@ -200,7 +205,6 @@ func structFieldWireToAst(src *schema.StructField) *genStructFieldDef {
 	dst := &genStructFieldDef{
 		Name:     src.Name,
 		Optional: src.Optional,
-		//Recursive: src.Recursive,
 	}
 
 	dst.Type = typeWireToGen(src.FieldType)
@@ -213,6 +217,7 @@ func typeWireToGen(src schema.FieldType) genFieldTypeRef {
 		return &genPrimitiveTypeRef{
 			Type: *src.Primitive,
 			Dict: src.DictName,
+			Enum: src.Enum,
 		}
 	}
 
@@ -236,3 +241,21 @@ func typeWireToGen(src schema.FieldType) genFieldTypeRef {
 
 	panic("unknown field type")
 }
+
+func enumSchemaToGen(src *schema.Enum) *genEnumDef {
+	dst := &genEnumDef{
+		Name: src.Name,
+	}
+	for i := range src.Fields {
+		dst.Fields = append(dst.Fields, enumFieldSchemaToGen(&src.Fields[i]))
+	}
+	return dst
+}
+
+func enumFieldSchemaToGen(src *schema.EnumField) *genEnumFieldDef {
+	dst := &genEnumFieldDef{
+		Name:  src.Name,
+		Value: src.Value,
+	}
+	return dst
+}
diff --git a/stefgen/generator/enums.go b/stefgen/generator/enums.go
new file mode 100644
index 00000000..19021954
--- /dev/null
+++ b/stefgen/generator/enums.go
@@ -0,0 +1,40 @@
+package generator
+
+import "strings"
+
+func (g *Generator) oEnums() error {
+	for _, enum := range g.compiledSchema.Enums {
+		err := g.oEnum(enum)
+		if err != nil {
+			return err
+		}
+	}
+
+	return g.lastErr
+}
+
+func (g *Generator) oEnum(enum *genEnumDef) error {
+	fields := []any{}
+
+	for _, field := range enum.Fields {
+		fieldData := map[string]any{
+			"Name":  field.Name,
+			"Value": field.Value,
+		}
+
+		fields = append(fields, fieldData)
+	}
+
+	data := map[string]any{
+		"EnumName": enum.Name,
+		"Fields":   fields,
+	}
+
+	templateName := "enum.go.tmpl"
+
+	if err := g.oTemplate(templateName, strings.ToLower(enum.Name), data); err != nil {
+		return err
+	}
+
+	return g.lastErr
+}
diff --git a/stefgen/generator/generator.go b/stefgen/generator/generator.go
index 590c9eab..d47c7cb5 100644
--- a/stefgen/generator/generator.go
+++ b/stefgen/generator/generator.go
@@ -57,6 +57,10 @@ func (g *Generator) GenFile(schema *schema.Schema) error {
 		return err
 	}
 
+	if err := g.oEnums(); err != nil {
+		return err
+	}
+
 	if err := g.oWriters(); err != nil {
 		return err
 	}
diff --git a/stefgen/generator/genschema.go b/stefgen/generator/genschema.go
index 2d07a970..04f23abd 100644
--- a/stefgen/generator/genschema.go
+++ b/stefgen/generator/genschema.go
@@ -12,6 +12,7 @@ type genSchema struct {
 	PackageName string
 	Structs     map[string]*genStructDef
 	Multimaps   map[string]*genMapDef
+	Enums       map[string]*genEnumDef
 }
 
 func (s *genSchema) SchemaStr() string {
@@ -66,12 +67,12 @@ func (a *genStructFieldDef) SetRecursive() {
 }
 
 type TypeFlags struct {
-	// PassByPtr indicates that the value of this type is passed by pointer to GoQualifiedType()
+	// PassByPtr indicates that the value of this type is passed by pointer to Exported()
 	// when it is a function parameter or when it is returned by a function.
 	PassByPtr bool
 
 	// StoreByPtr indicates that struct fields of the value of this type is stored as a
-	// pointer to GoQualifiedType(). If this is false that the fields are simply of GoQualifiedType().
+	// pointer to Exported(). If this is false that the fields are simply of Exported().
 	StoreByPtr bool
 
 	// TakePtr is true a pointer must be taken of the field to pass it as a parameter.
@@ -82,8 +83,18 @@ type genFieldTypeRef interface {
 	TypeName() string
 	IsPrimitive() bool
 
-	// GoQualifiedType is the fully qualified Go type for this field type.
-	GoQualifiedType() string
+	// Exported is the fully qualified exported (public) Go type.
+	Exported() string
+
+	// Storage is the underlying storage type.
+	Storage() string
+
+	// ToExported converts argument to exported type if necessary.
+	ToExported(arg string) string
+
+	// ToStorage converts argument to storage type if necessary.
+	ToStorage(arg string) string
+
 	EncoderType() string
 	EqualFunc() string
 	CompareFunc() string
@@ -99,6 +110,7 @@ type genFieldTypeRef interface {
 type genPrimitiveTypeRef struct {
 	Type schema.PrimitiveFieldType
 	Dict string
+	Enum string
 }
 
 func (r *genPrimitiveTypeRef) IsPrimitive() bool {
@@ -125,7 +137,42 @@ func (r *genPrimitiveTypeRef) DictName() string {
 	return r.Dict
 }
 
-func (r *genPrimitiveTypeRef) GoQualifiedType() string {
+// Storage returns the underlying type of fields.
+func (r *genPrimitiveTypeRef) Storage() string {
+	if r.Type == schema.PrimitiveTypeBytes {
+		return "pkg.Bytes"
+	}
+	return r.TypeName()
+}
+
+// ToStorage converts the argument to the underlying type
+// if the underlying type is different than the exported type.
+// If the types are the same, no conversion is performed.
+func (r *genPrimitiveTypeRef) ToStorage(arg string) string {
+	if r.Enum != "" {
+		return r.Storage() + "(" + arg + ")"
+	}
+	return arg
+}
+
+// ToExported converts the argument to the exported type
+// if the underlying storage type is different than the exported type.
+// If the types are the same, no conversion is performed.
+func (r *genPrimitiveTypeRef) ToExported(arg string) string {
+	if r.Enum != "" {
+		return r.Enum + "(" + arg + ")"
+	}
+	return arg
+}
+
+// Exported returns the fully qualified Go type for this field type
+// that will be used for exported setters/getters.
+// The underlying storage type may be different (e.g. if it is an Enum)
+// and is available via Storage().
+func (r *genPrimitiveTypeRef) Exported() string {
+	if r.Enum != "" {
+		return r.Enum
+	}
 	if r.Type == schema.PrimitiveTypeBytes {
 		return "pkg.Bytes"
 	}
@@ -314,10 +361,22 @@ func (r *genStructTypeRef) DictGoType() string {
 	return r.DictName()
 }
 
-func (r *genStructTypeRef) GoQualifiedType() string {
+func (r *genStructTypeRef) Exported() string {
 	return r.TypeName()
 }
 
+func (r *genStructTypeRef) Storage() string {
+	return r.TypeName()
+}
+
+func (r *genStructTypeRef) ToExported(arg string) string {
+	return arg
+}
+
+func (r *genStructTypeRef) ToStorage(arg string) string {
+	return arg
+}
+
 func (r *genStructTypeRef) TypeName() string {
 	return r.Name
 }
@@ -382,10 +441,22 @@ func (r *genArrayTypeRef) DictGoType() string {
 	return ""
 }
 
-func (r *genArrayTypeRef) GoQualifiedType() string {
+func (r *genArrayTypeRef) Exported() string {
+	return r.TypeName()
+}
+
+func (r *genArrayTypeRef) Storage() string {
 	return r.TypeName()
 }
 
+func (r *genArrayTypeRef) ToExported(arg string) string {
+	return r.ToExported(arg)
+}
+
+func (r *genArrayTypeRef) ToStorage(arg string) string {
+	return r.ToStorage(arg)
+}
+
 func (r *genArrayTypeRef) TypeName() string {
 	str := r.ElemType.TypeName() + "Array"
 	// Make sure the type name is exported.
@@ -430,10 +501,22 @@ func (r *genMultimapTypeRef) DictGoType() string {
 	return ""
 }
 
-func (r *genMultimapTypeRef) GoQualifiedType() string {
+func (r *genMultimapTypeRef) Exported() string {
+	return r.TypeName()
+}
+
+func (r *genMultimapTypeRef) Storage() string {
 	return r.TypeName()
 }
 
+func (r *genMultimapTypeRef) ToExported(arg string) string {
+	return arg
+}
+
+func (r *genMultimapTypeRef) ToStorage(arg string) string {
+	return arg
+}
+
 func (r *genMultimapTypeRef) TypeName() string {
 	str := r.Name
 	str = strings.ToUpper(str[:1]) + str[1:]
@@ -467,3 +550,13 @@ func (r *genMultimapTypeRef) Flags() TypeFlags {
 		TakePtr:    true,
 	}
 }
+
+type genEnumDef struct {
+	Name   string
+	Fields []*genEnumFieldDef
+}
+
+type genEnumFieldDef struct {
+	Name  string
+	Value uint64
+}
diff --git a/stefgen/templates/array.go.tmpl b/stefgen/templates/array.go.tmpl
index f5832986..10bab5f7 100644
--- a/stefgen/templates/array.go.tmpl
+++ b/stefgen/templates/array.go.tmpl
@@ -15,7 +15,7 @@ var _ = encoders.StringEncoder{}
 
 // {{ .ArrayName }} is a variable size array.
 type {{ .ArrayName }} struct {
-	elems []{{if .IsStructType}}*{{end}}{{.ElemType.GoQualifiedType}}
+	elems []{{if .IsStructType}}*{{end}}{{.ElemType.Storage}}
 
 	parentModifiedFields *modifiedFields
 	parentModifiedBit uint64
@@ -52,7 +52,7 @@ func (e *{{.ArrayName}}) byteSize() uint {
 // CopyFromSlice copies from a slice into this array. The length
 // of the array will be equal to the length of slice and elements of
 // the array will be assigned from elements of the slice.
-func (e* {{.ArrayName}}) CopyFromSlice(src []{{.ElemType.GoQualifiedType}}) {
+func (e* {{.ArrayName}}) CopyFromSlice(src []{{.ElemType.Exported}}) {
 	if !slices.Equal(e.elems, src) {
 		e.elems = pkg.EnsureLen(e.elems, len(src))
 		copy(e.elems, src)
@@ -63,8 +63,8 @@ func (e* {{.ArrayName}}) CopyFromSlice(src []{{.ElemType.GoQualifiedType}}) {
 {{end}}
 
 // Append a new element at the end of the array.
-func (e* {{.ArrayName}}) Append(val {{if .IsStructType}}*{{end}}{{.ElemType.GoQualifiedType}}) {
-	e.elems = append(e.elems, val)
+func (e* {{.ArrayName}}) Append(val {{if .IsStructType}}*{{end}}{{.ElemType.Exported}}) {
+	e.elems = append(e.elems, {{.ElemType.ToStorage "val"}})
 	e.markModified()
 }
 
@@ -92,7 +92,7 @@ func copy{{.ArrayName}}(dst* {{.ArrayName}}, src *{{.ArrayName}}) {
 	}
 	if len(src.elems)>0 {
 		// Allocate all elements at once.
-		elems := make([]{{.ElemType.GoQualifiedType}}, len(src.elems))
+		elems := make([]{{.ElemType.Storage}}, len(src.elems))
 		for i := range src.elems {
 			{{if not .ElemType.IsPrimitive -}}
 			// Init the element.
@@ -140,8 +140,8 @@ func (e *{{.ArrayName}}) Len() int {
 }
 
 // At returns element at index i.
-func (m *{{.ArrayName}}) At(i int) {{if .IsStructType}}*{{end}}{{.ElemType.GoQualifiedType}} {
-	return m.elems[i]
+func (m *{{.ArrayName}}) At(i int) {{if .IsStructType}}*{{end}}{{.ElemType.Exported}} {
+	return {{.ElemType.ToExported "m.elems[i]"}}
 }
 
 // EnsureLen ensures the length of the array is equal to newLen.
@@ -150,12 +150,12 @@ func (e *{{.ArrayName}}) EnsureLen(newLen int) {
 	oldLen := len(e.elems)
 	if newLen > oldLen {
 		// Grow the array
-		e.elems = append(e.elems, make([]{{if .IsStructType}}*{{end}}{{.ElemType.GoQualifiedType}}, newLen-oldLen)...)
+		e.elems = append(e.elems, make([]{{if .IsStructType}}*{{end}}{{.ElemType.Storage}}, newLen-oldLen)...)
 		e.markModified()
 		{{- if .IsStructType}}
 		// Initialize newlly added elements.
 		for ; oldLen<newLen; oldLen++ {
-			e.elems[oldLen] = new({{.ElemType.GoQualifiedType}})
+			e.elems[oldLen] = new({{.ElemType.Storage}})
 			e.elems[oldLen].init(e.parentModifiedFields, e.parentModifiedBit)
 		}
 		{{- end}}
@@ -236,7 +236,7 @@ type {{ .ArrayName }}Encoder struct {
 	encoder {{if .Recursive -}}*{{end}}{{.ElemType.EncoderType}}Encoder
 	prevLen int
 	state* WriterState
-	lastVal {{.ElemType.GoQualifiedType}}
+	lastVal {{.ElemType.Storage}}
 }
 
 func (e *{{ .ArrayName }}Encoder) Init(state* WriterState, columns *pkg.WriteColumnSet) error {
@@ -309,8 +309,8 @@ type {{ .ArrayName }}Decoder struct {
 	column *pkg.ReadableColumn
 	decoder {{if .Recursive -}}*{{end}}{{.ElemType.EncoderType}}Decoder
 	prevLen int
-	lastVal {{.ElemType.GoQualifiedType}}
-	lastValPtr *{{.ElemType.GoQualifiedType}}
+	lastVal {{.ElemType.Storage}}
+	lastValPtr *{{.ElemType.Storage}}
 }
 
 // Init is called once in the lifetime of the stream.
diff --git a/stefgen/templates/enum.go.tmpl b/stefgen/templates/enum.go.tmpl
new file mode 100644
index 00000000..ece9a889
--- /dev/null
+++ b/stefgen/templates/enum.go.tmpl
@@ -0,0 +1,9 @@
+package {{ .PackageName }}
+
+type {{.EnumName}} uint64
+
+const (
+    {{ range .Fields }}
+    {{$.EnumName}}{{.Name}} {{$.EnumName}} = {{.Value}}
+    {{- end }}
+)
diff --git a/stefgen/templates/multimap.go.tmpl b/stefgen/templates/multimap.go.tmpl
index 1836c2ec..88806cc5 100644
--- a/stefgen/templates/multimap.go.tmpl
+++ b/stefgen/templates/multimap.go.tmpl
@@ -22,15 +22,15 @@ type {{ .MultimapName }} struct {
 }
 
 type {{ .MultimapName }}Elem struct {
-	key   {{if.Key.Type.Flags.StoreByPtr}}*{{end}}{{.Key.Type.GoQualifiedType}}
-	value {{if.Value.Type.Flags.StoreByPtr}}*{{end}}{{.Value.Type.GoQualifiedType}}
+	key   {{if.Key.Type.Flags.StoreByPtr}}*{{end}}{{.Key.Type.Storage}}
+	value {{if.Value.Type.Flags.StoreByPtr}}*{{end}}{{.Value.Type.Storage}}
 }
 
-func (e* {{ .MultimapName }}Elem) Key() {{if.Key.Type.Flags.PassByPtr}}*{{end}}{{.Key.Type.GoQualifiedType}} {
+func (e* {{ .MultimapName }}Elem) Key() {{if.Key.Type.Flags.PassByPtr}}*{{end}}{{.Key.Type.Exported}} {
 	return {{if.Key.Type.Flags.PassByPtr}}&{{end}}e.key
 }
 
-func (e* {{ .MultimapName }}Elem) Value() {{if.Value.Type.Flags.PassByPtr}}*{{end}}{{.Value.Type.GoQualifiedType}} {
+func (e* {{ .MultimapName }}Elem) Value() {{if.Value.Type.Flags.PassByPtr}}*{{end}}{{.Value.Type.Exported}} {
 	return {{if.Value.Type.Flags.PassByPtr}}&{{end}}e.value
 }
 
@@ -64,15 +64,15 @@ func (m *{{.MultimapName}}) EnsureLen(newLen int) {
 		m.elems = pkg.EnsureLen(m.elems, newLen)
 		{{if or .Key.Type.Flags.StoreByPtr .Value.Type.Flags.StoreByPtr}}
 		{{- if .Key.Type.Flags.StoreByPtr}}
-		var	newKeys []{{.Key.Type.GoQualifiedType}}
+		var	newKeys []{{.Key.Type.Storage}}
 		if newLen>m.initedCount {
-			newKeys = make([]{{.Key.Type.GoQualifiedType}},newLen-m.initedCount)
+			newKeys = make([]{{.Key.Type.Storage}},newLen-m.initedCount)
 		}
 		{{- end}}
 		{{- if .Value.Type.Flags.StoreByPtr}}
-		var	newVals []{{.Value.Type.GoQualifiedType}}
+		var	newVals []{{.Value.Type.Storage}}
 		if newLen>m.initedCount {
-			newVals = make([]{{.Value.Type.GoQualifiedType}},newLen-m.initedCount)
+			newVals = make([]{{.Value.Type.Storage}},newLen-m.initedCount)
 		}
 		{{- end}}
 		// Set pointers to elements in the slice and init elements with pointers to the parent struct.
@@ -129,26 +129,26 @@ func (m* {{.MultimapName}}) markUnmodifiedRecursively() {
 
 
 {{if and (not .Key.Type.MustClone) (not .Value.Type.MustClone)}}
-func (m *{{.MultimapName}}) Append(k {{.Key.Type.GoQualifiedType}}, v {{.Value.Type.GoQualifiedType}}) {
-	m.elems = append(m.elems, {{.MultimapName}}Elem{key: k, value: v})
+func (m *{{.MultimapName}}) Append(k {{.Key.Type.Exported}}, v {{.Value.Type.Exported}}) {
+	m.elems = append(m.elems, {{.MultimapName}}Elem{key: {{.Key.Type.ToStorage "k"}}, value: {{.Value.Type.ToStorage "v"}}})
 	m.markModified()
 }
 {{end}}
 
 {{if not .Key.Type.MustClone}}
 // SetKey sets the key of the element at index i.
-func (m *{{.MultimapName}}) SetKey(i int, k {{.Key.Type.GoQualifiedType}}) {
-	if m.elems[i].key != k {
-		m.elems[i].key = k
+func (m *{{.MultimapName}}) SetKey(i int, k {{.Key.Type.Exported}}) {
+	if m.elems[i].key != {{.Key.Type.ToStorage "k"}} {
+		m.elems[i].key = {{.Key.Type.ToStorage "k"}}
 		m.markModified()
 	}
 }
 
 {{if .Value.Type.IsPrimitive}}
 // SetValue sets the value of the element at index i.
-func (m *{{.MultimapName}}) SetValue(i int, v {{.Value.Type.GoQualifiedType}}) {
-	if !{{.Value.Type.EqualFunc}}(m.elems[i].value, v) {
-		m.elems[i].value = v
+func (m *{{.MultimapName}}) SetValue(i int, v {{.Value.Type.Exported}}) {
+	if !{{.Value.Type.EqualFunc}}(m.elems[i].value, {{.Value.Type.ToStorage "v"}}) {
+		m.elems[i].value = {{.Value.Type.ToStorage "v"}}
 		m.markModified()
 	}
 }
diff --git a/stefgen/templates/oneof.go.tmpl b/stefgen/templates/oneof.go.tmpl
index 61d2c03b..b2515bb6 100644
--- a/stefgen/templates/oneof.go.tmpl
+++ b/stefgen/templates/oneof.go.tmpl
@@ -21,7 +21,7 @@ type {{ .StructName }} struct {
     // The current type of the oneof.
 	typ {{$.StructName }}Type
     {{ range .Fields }}
-    {{.name}} {{if .Type.Flags.StoreByPtr}}*{{end}}{{ .Type.GoQualifiedType }}
+    {{.name}} {{if .Type.Flags.StoreByPtr}}*{{end}}{{ .Type.Storage }}
     {{- end }}
 
     // Pointer to parent's modifiedFields
@@ -41,7 +41,7 @@ func (s *{{ $.StructName }}) init(parentModifiedFields *modifiedFields, parentMo
 
     {{ range .Fields }}
     {{- if .Type.Flags.StoreByPtr}}
-    s.{{.name}} = &{{ .Type.GoQualifiedType }}{}
+    s.{{.name}} = &{{ .Type.Storage }}{}
     {{- end }}
 	{{- if not .Type.IsPrimitive }}
     s.{{.name}}.init(parentModifiedFields, parentModifiedBit)
@@ -74,15 +74,19 @@ func (s *{{ $.StructName }}) SetType(typ {{$.StructName }}Type) {
 {{ range .Fields }}
 // {{.Name}} returns the value if the contained type is currently {{$.StructName }}Type{{.Name}}.
 // The caller must check the type via Type() before attempting to call this function.
-func (s *{{ $.StructName }}) {{.Name}}() {{if .Type.Flags.PassByPtr}}*{{end}}{{.Type.GoQualifiedType}} {
+func (s *{{ $.StructName }}) {{.Name}}() {{if .Type.Flags.PassByPtr}}*{{end}}{{.Type.Exported}} {
+{{- if .Type.IsPrimitive}}
+    return {{.Type.ToExported (print "s." .name)}}
+{{- else}}
 	return {{if and .Type.Flags.PassByPtr (not .Type.Flags.StoreByPtr)}}&{{end}}s.{{.name}}
+{{- end}}
 }
 
 {{if .Type.IsPrimitive}}
 // Set{{.Name}} sets the value to the specified value and sets the type to {{$.StructName }}Type{{.Name}}.
-func (s *{{ $.StructName }}) Set{{.Name}}(v {{if .PassByPointer}}*{{end}}{{.Type.GoQualifiedType}}) {
-    if !{{ .Type.EqualFunc }}({{if and .PassByPointer (not .IsStructType)}}&{{end}}s.{{.name}}, v) || s.typ!={{$.StructName }}Type{{.Name}} {
-		s.{{.name}} = v
+func (s *{{ $.StructName }}) Set{{.Name}}(v {{if .PassByPointer}}*{{end}}{{.Type.Exported}}) {
+    if !{{ .Type.EqualFunc }}(s.{{.name}}, {{.Type.ToStorage "v"}}) || s.typ!={{$.StructName }}Type{{.Name}} {
+		s.{{.name}} = {{.Type.ToStorage "v"}}
 		s.typ = {{$.StructName }}Type{{.Name}}
         s.markParentModified()
     }
@@ -115,7 +119,7 @@ func copy{{.StructName}}(dst *{{.StructName}}, src *{{.StructName}}) {
             {{- if .Type.Flags.TakePtr}}&{{end}}dst.{{.name }},
             {{- if .Type.Flags.TakePtr}}&{{end}}src.{{.name}})
         {{- else}}
-        dst.Set{{.Name}}(src.{{.name}})
+        dst.Set{{.Name}}({{.Type.ToExported (print "src." .name)}})
         {{- end}}
     {{- end}}
     }
@@ -225,7 +229,7 @@ func (s *{{ .StructName }}) mutateRandom(random *rand.Rand) {
         {{- if not .Type.IsPrimitive }}
             s.{{.name}}.mutateRandom(random)
         {{- else }}
-            s.Set{{.Name}}({{ .Type.RandomFunc }}(random))
+            s.Set{{.Name}}({{.Type.ToExported (print .Type.RandomFunc "(random)")}})
         {{- end}}
         }
     {{- end }}
diff --git a/stefgen/templates/struct.go.tmpl b/stefgen/templates/struct.go.tmpl
index 2f54dc67..1e32a6de 100644
--- a/stefgen/templates/struct.go.tmpl
+++ b/stefgen/templates/struct.go.tmpl
@@ -18,7 +18,7 @@ var _ = encoders.StringEncoder{}
 
 type {{ .StructName }} struct {
     {{ range .Fields }}
-    {{.name}} {{if .Type.Flags.StoreByPtr}}*{{end}}{{ .Type.GoQualifiedType }}
+    {{.name}} {{if .Type.Flags.StoreByPtr}}*{{end}}{{ .Type.Storage }}
     {{- end }}
 
     // modifiedFields keeps track of which fields are modified.
@@ -66,7 +66,7 @@ func (s *{{ $.StructName }}) init(parentModifiedFields *modifiedFields, parentMo
 
     {{ range .Fields }}
     {{- if .Type.Flags.StoreByPtr}}
-    s.{{.name}} = &{{ .Type.GoQualifiedType }}{}
+    s.{{.name}} = &{{ .Type.Storage }}{}
     {{- end }}
 	{{- if not .Type.IsPrimitive }}
     s.{{.name}}.init(&s.modifiedFields, fieldModified{{ $.StructName }}{{.Name}})
@@ -75,16 +75,20 @@ func (s *{{ $.StructName }}) init(parentModifiedFields *modifiedFields, parentMo
 }
 
 {{ range .Fields }}
-func (s *{{ $.StructName }}) {{.Name}}() {{if .Type.Flags.PassByPtr}}*{{end}}{{.Type.GoQualifiedType}} {
-	return {{if and .Type.Flags.PassByPtr (not .Type.Flags.StoreByPtr)}}&{{end}}s.{{.name}}
+func (s *{{ $.StructName }}) {{.Name}}() {{if .Type.Flags.PassByPtr}}*{{end}}{{.Type.Exported}} {
+{{- if .Type.IsPrimitive}}
+	return {{.Type.ToExported (print "s." .name)}}
+{{- else}}
+    return {{if and .Type.Flags.PassByPtr (not .Type.Flags.StoreByPtr)}}&{{end}}s.{{.name}}
+{{- end}}
 }
 
 {{if .Type.IsPrimitive}}
 // Set{{.Name}} sets the value of {{.Name}} field.
-func (s *{{ $.StructName }}) Set{{.Name}}(v {{if .PassByPointer}}*{{end}}{{.Type.GoQualifiedType}}) {
-    if !{{ .Type.EqualFunc }}({{if and .PassByPointer (not .IsStructType)}}&{{end}}s.{{.name}}, v)
+func (s *{{ $.StructName }}) Set{{.Name}}(v {{.Type.Exported}}) {
+    if !{{ .Type.EqualFunc }}(s.{{.name}}, {{.Type.ToStorage "v"}})
         {{- if .Optional}}|| s.optionalFieldsPresent & fieldPresent{{ $.StructName }}{{.Name}}==0{{end}} {
-		s.{{.name}} = v
+		s.{{.name}} = {{.Type.ToStorage "v"}}
         s.mark{{.Name}}Modified()
         {{- if .Optional}}
 		s.optionalFieldsPresent |= fieldPresent{{ $.StructName }}{{.Name}}
@@ -158,12 +162,12 @@ func copy{{.StructName}}(dst *{{.StructName}}, src *{{.StructName}}) {
     {{- else}}
 	{{- if .Optional}}
 	if src.Has{{.Name}}() {
-		dst.Set{{.Name}}(src.{{.name}})
+		dst.Set{{.Name}}({{.Type.ToExported (print "src." .name)}})
 	} else {
 		dst.Unset{{.Name}}()
 	}
 	{{else}}
-    dst.Set{{.Name}}(src.{{.name}})
+    dst.Set{{.Name}}({{.Type.ToExported (print "src." .name)}})
     {{- end}}
     {{- end}}
     {{- end}}
@@ -196,7 +200,7 @@ func (s *{{ .StructName }}) mutateRandom(random *rand.Rand) {
     {{- if not .Type.IsPrimitive }}
         s.{{.name}}.mutateRandom(random)
     {{- else }}
-        s.Set{{.Name}}({{ .Type.RandomFunc }}(random))
+        s.Set{{.Name}}({{.Type.ToExported (print .Type.RandomFunc "(random)")}})
     {{- end}}
     }
 {{- end }}