xsd

Documentation

Index

• type Annotation
• type Any
• type AnyAttribute
• type Attribute
• type AttributeGroup
• type Choice
• type ComplexContent
• type ComplexType
• type Element
• type Enumeration
• type Extension
• type Import
• type Length
• type List
• type MaxInclusive
• type MinInclusive
• type Pattern
• type Restriction
• type Schema
• type Sequence
• type SimpleContent
• type SimpleType
• type Union

Types

type Annotation

type Annotation struct {
	AppInfo       *string `xml:"appinfo"`
	Documentation string  `xml:"documentation"`
}

type Any

type Any struct {
	MaxOccurs       *string `xml:"maxOccurs,attr"`
	MinOccurs       *int    `xml:"minOccurs,attr"`
	Namespace       string  `xml:"namespace,attr"`
	ProcessContents string  `xml:"processContents,attr"`
}

type AnyAttribute

type AnyAttribute struct {
	Namespace       string `xml:"namespace,attr"`
	ProcessContents string `xml:"processContents,attr"`
}

type Attribute

type Attribute struct {
	Default *string `xml:"default,attr"`
	Name    *string `xml:"name,attr"`
	Ref     *string `xml:"ref,attr"`
	Type    *string `xml:"type,attr"`
	Use     *string `xml:"use,attr"`
}

type AttributeGroup

type AttributeGroup struct {
	Name      string      `xml:"name,attr"`
	Ref       *string     `xml:"ref,attr"`
	Attribute []Attribute `xml:"attribute"`
}

type Choice

type Choice struct {
	MaxOccurs  *string     `xml:"maxOccurs,attr"`
	MinOccurs  *int        `xml:"minOccurs,attr"`
	Annotation *Annotation `xml:"annotation"`
	Element    []Element   `xml:"element"`
}

type ComplexContent

type ComplexContent struct {
	Mixed     *bool     `xml:"mixed,attr"`
	Extension Extension `xml:"extension"`
}

type ComplexType

type ComplexType struct {
	Abstract       *bool           `xml:"abstract,attr"`
	Final          *string         `xml:"final,attr"`
	Mixed          *bool           `xml:"mixed,attr"`
	Name           string          `xml:"name,attr"`
	Annotation     *Annotation     `xml:"annotation"`
	Attribute      []Attribute     `xml:"attribute"`
	AttributeGroup *AttributeGroup `xml:"attributeGroup"`
	Choice         *Choice         `xml:"choice"`
	ComplexContent *ComplexContent `xml:"complexContent"`
	Sequence       *Sequence       `xml:"sequence"`
	SimpleContent  *SimpleContent  `xml:"simpleContent"`
}

type Element

type Element struct {
	Abstract          *bool       `xml:"abstract,attr"`
	Default           *string     `xml:"default,attr"`
	MaxOccurs         *string     `xml:"maxOccurs,attr"`
	MinOccurs         *int        `xml:"minOccurs,attr"`
	Name              *string     `xml:"name,attr"`
	Ref               *string     `xml:"ref,attr"`
	SubstitutionGroup *string     `xml:"substitutionGroup,attr"`
	Type              *string     `xml:"type,attr"`
	Annotation        *Annotation `xml:"annotation"`
}

type Enumeration

type Enumeration struct {
	Value string `xml:"value,attr"`
}

type Extension

type Extension struct {
	Base         string        `xml:"base,attr"`
	AnyAttribute *AnyAttribute `xml:"anyAttribute"`
	Attribute    []Attribute   `xml:"attribute"`
	Sequence     *Sequence     `xml:"sequence"`
}

type Import

type Import struct {
	Namespace      string `xml:"namespace,attr"`
	SchemaLocation string `xml:"schemaLocation,attr"`
}

type Length

type Length struct {
	Value int `xml:"value,attr"`
}

type List

type List struct {
	ItemType string `xml:"itemType,attr"`
}

type MaxInclusive

type MaxInclusive struct {
	Value float64 `xml:"value,attr"`
}

type MinInclusive

type MinInclusive struct {
	Value float64 `xml:"value,attr"`
}

type Pattern

type Pattern struct {
	Value string `xml:"value,attr"`
}

type Restriction

type Restriction struct {
	Base         string        `xml:"base,attr"`
	Enumeration  []Enumeration `xml:"enumeration"`
	Length       *Length       `xml:"length"`
	MaxInclusive *MaxInclusive `xml:"maxInclusive"`
	MinInclusive *MinInclusive `xml:"minInclusive"`
	Pattern      Pattern       `xml:"pattern"`
}

type Schema

type Schema struct {
	Annotation     *Annotation     `xml:"annotation"`
	AttributeGroup *AttributeGroup `xml:"attributeGroup"`
	ComplexType    []ComplexType   `xml:"complexType"`
	Element        []Element       `xml:"element"`
	Import         []Import        `xml:"import"`
	SimpleType     []SimpleType    `xml:"simpleType"`
}

type Sequence

type Sequence struct {
	MaxOccurs *string   `xml:"maxOccurs,attr"`
	MinOccurs *int      `xml:"minOccurs,attr"`
	Any       *Any      `xml:"any"`
	Choice    []Choice  `xml:"choice"`
	Element   []Element `xml:"element"`
}

type SimpleContent

type SimpleContent struct {
	Extension Extension `xml:"extension"`
}

type SimpleType

type SimpleType struct {
	Name        string       `xml:"name,attr"`
	Annotation  *Annotation  `xml:"annotation"`
	List        *List        `xml:"list"`
	Restriction *Restriction `xml:"restriction"`
	Union       *Union       `xml:"union"`
}

type Union

type Union struct {
	MemberTypes string `xml:"memberTypes,attr"`
}