asn1go

type AnyType struct {
	// Identifier is set if IDENTIFIED BY is provided.
	Identifier Identifier
}

type Assignment interface {
	Reference() Reference
}

type AssignmentList []Assignment

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 {
	ExtensionAddition
	// contains filtered or unexported methods
}

type ComponentTypeList []ComponentType

type ComponentTypeLists struct {
	Components         ComponentTypeList
	ExtensionAdditions ExtensionAdditions
	TrailingComponents ComponentTypeList
}

type ComponentsOfComponentType struct {
	Type Type
}

type Constraint struct {
	ConstraintSpec ConstraintSpec
}

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

type ConstraintedType struct {
	Type       Type
	Constraint Constraint
}

type DefinedValue struct {
	// ModuleName, if non-empty, specifies module where value was defined.
	ModuleName ModuleReference
	// ValueName is name of the value.
	// It should always be provided.
	ValueName ValueReference
}

type DefinitiveIdentifier []DefinitiveObjIdComponent

type DefinitiveObjIdComponent struct {
	Name string
	Id   int
}

type ElementSetSpec interface {
	Elements
	// contains filtered or unexported methods
}

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

type EnumeratedType struct {
	// Alternatives of the enumeration.
	RootEnumeration       []EnumerationItem
	AdditionalEnumeration []EnumerationItem
}

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

type Exclusions struct {
	Elements Elements
}

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

type ExtensionAdditions []ExtensionAddition

type GenParams struct {
	// Package is go package name.
	// If not specified, ASN.1 module name will be used to derive go module name.
	Package string
	// Type is a type of code generation to run.
	// TODO: deprecate in favor of separate New methods.
	Type GenType
	// IntegerRepr controls how INTEGER type is expressed in generated go code.
	IntegerRepr IntegerRepr
}

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 InnerTypeConstraint struct{}

type IntegerRepr string

type IntegerType struct {
	NamedNumberList []NamedNumber
}

type IntersectionElements struct {
	Elements   Elements
	Exclusions Exclusions
}

type Intersections []IntersectionElements

type ModuleBody struct {
	AssignmentList AssignmentList
	Imports        []SymbolsFromModule
}

type ModuleDefinition struct {
	ModuleIdentifier ModuleIdentifier
	// TagDefault is default tagging behavior, one of TAGS_ constants.
	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 is index of the bit.
	// Will have Number or DefinedValue type.
	Index Value
}

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

type NamedNumber struct {
	Name  Identifier
	Value NamedNumberValue
}

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

type NamedType struct {
	Identifier Identifier
	Type       Type
}

type NullType struct{}

type Number int

type ObjectIdElement struct {
	// Name is non-empty in name-and-number form.
	Name string
	// ID is set in Number or NameAndNumber form, if number is specified as number literal.
	ID int
	// Reference is set in NameAndNumber form, when number is provided as DefinedValue.
	// NameForm is always parsed as Reference.
	Reference *DefinedValue
}

type ObjectIdentifierType struct{}

type ObjectIdentifierValue []ObjectIdElement

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 is a lexem value for restricted string (e.g. IA5String).
	LexType int
}

type SequenceOfType struct {
	Type Type
}

type SequenceType struct {
	Components         ComponentTypeList
	ExtensionAdditions ExtensionAdditions
}

type SetOfType struct {
	Type Type
}

type SetType struct {
	Components         ComponentTypeList
	ExtensionAdditions ExtensionAdditions
}

type SingleValue struct {
	Value
}

type SizeConstraint struct {
	Constraint Constraint
}

type SubtypeConstraint []ElementSetSpec

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

type SymbolsFromModule struct {
	SymbolList []Symbol
	Module     GlobalModuleReference
}

type Tag struct {
	// Class is a tag class, one of CLASS_ constants.
	// E.g. UNIVERSAL, APPLICATION.
	Class int
	// ClassNumber is a tag value.
	// Will hold DefinedValue or Number.
	ClassNumber Value
}

type TaggedType struct {
	// Tag assigned to a type.
	Tag Tag
	// Type that is being tagged.
	Type Type
	// TagType is one of TAGS_ constants.
	// E.g. IMPLICIT, EXPLICIT.
	TagType int
	// HasTagType is set to true if TagType was explicitly specified in module syntax.
	// Otherwise, TagType would hold module default.
	HasTagType bool // true if explicitly set
}

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

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