asn1go

type Assignment interface {
	Reference() Reference
}

type AssignmentList []Assignment

type AstNode interface{}

type BitStringType struct {
	NamedBits []NamedBit
}

type Boolean bool

type BooleanType struct{}

type CharacterStringType struct{}

type ChoiceExtension interface {
	// contains filtered or unexported methods
}

type ChoiceType struct {
	AlternativeTypeList []NamedType
	ExtensionTypes      []ChoiceExtension
}

type CodeGenerator interface {
	Generate(module ModuleDefinition, writer io.Writer) error
}

type ComponentType interface {
	IsComponentType()
}

type ComponentTypeList []ComponentType

type ComponentsOfComponentType struct {
	Type Type
}

type Constraint struct {
	ConstraintSpec ConstraintSpec
}

type ConstraintSpec interface {
	IsConstraintSpec()
}

type ConstraintedType struct {
	Type       Type
	Constraint Constraint
}

type DefinedValue struct{}

type DefinitiveIdentifier []DefinitiveObjIdComponent

type DefinitiveObjIdComponent struct {
	Name string
	Id   int
}

type ElementSetSpec interface {
	Elements
	IsElementSpec()
}

type Elements interface {
	IsElements()
}

type Exclusions struct {
	Elements Elements
}

type GenParams struct {
	Package string
	Prefix  string
	Type    GenType
}

type GenType int

type GeneralConstraint struct{}

type GlobalModuleReference struct {
	Reference          string
	AssignedIdentifier Value
}

type IdentifiedIntegerValue struct {
	Name string
	// contains filtered or unexported fields
}

type Identifier string

type IntegerType struct {
	NamedNumberList map[string]int
}

type IntersectionElements struct {
	Elements   Elements
	Exclusions Exclusions
}

type Intersections []IntersectionElements

type ModuleBody struct {
	AssignmentList AssignmentList
	Imports        []SymbolsFromModule
}

type ModuleDefinition struct {
	ModuleIdentifier     ModuleIdentifier
	TagDefault           int
	ExtensibilityImplied bool
	ModuleBody           ModuleBody
}

type ModuleIdentifier struct {
	Reference            string
	DefinitiveIdentifier DefinitiveIdentifier
}

type ModuleReference string

type MyLexer struct {
	// contains filtered or unexported fields
}

type NamedBit struct {
	Name  Identifier
	Index Value // Number or DefinedValue
}

type NamedComponentType struct {
	NamedType  NamedType
	IsOptional bool
	Default    *Value
}

type NamedType struct {
	Identifier Identifier
	Type       Type
}

type NullType struct{}

type Number int

type ObjIdComponents interface {
	IsObjectIdComponent() bool // fake method for grouping
}

type ObjectIdElement struct {
	Name      string
	Id        int
	Reference *DefinedValue // nil if Id is set explicitly
}

type ObjectIdentifierType struct{}

type ObjectIdentifierValue []ObjIdComponents

type OctetStringType struct{}

type RangeEndpoint struct {
	Value  Value
	IsOpen bool // X<..<X
}

type Real float64

type RealType struct{}

type Reference interface {
	Name() string
}

type RestrictedStringType struct {
	LexType int
}

type SequenceOfType struct {
	Type Type
}

type SequenceType struct {
	Components ComponentTypeList
}

type SingleValue struct {
	Value
}

type SizeConstraint struct {
	Constraint Constraint
}

type SubtypeConstraint []ElementSetSpec

type Symbol interface {
	IsSymbol()
}

type SymbolsFromModule struct {
	SymbolList []Symbol
	Module     GlobalModuleReference
}

type Tag struct {
	Class       int
	ClassNumber Value // either DefinedValue or Number
}

type TaggedType struct {
	Tag        Tag
	Type       Type
	TagType    int  // one of TAGS_*
	HasTagType bool // true if explicitly set
}

type Type interface {
	Zero() interface{}
}

type TypeAssignment struct {
	TypeReference TypeReference
	Type          Type
}

type TypeConstraint struct {
	Type Type
}

type TypeReference string

type Unions []Intersections

type Value interface {
	Type() Type
}

type ValueAssignment struct {
	ValueReference ValueReference
	Type           Type
	Value          Value
}

type ValueRange struct {
	LowerEndpoint RangeEndpoint
	UpperEndpoint RangeEndpoint
}

type ValueReference string