jsonschema

package module

Go to main page

Versions in this module

v0

v0.2.1

Mar 29, 2021

v0.2.0

May 21, 2020

Changes in this version

+ var MaxKeywordErrStringLen = 20

+ func DataTypeWithHint(data interface{}, hint string) string

+ func FetchSchema(ctx context.Context, uri string, schema *Schema) error

+ func GetKeywordInsertOrder(prop string) int

+ func GetKeywordOrder(prop string) int

+ func IsLocalSchemaID(id string) bool

+ func IsNotSupportedKeyword(prop string) bool

+ func IsRegisteredKeyword(prop string) bool

+ func IsRegistryLoaded() bool

+ func LoadDraft2019_09()

+ func RegisterKeyword(prop string, maker KeyMaker)

+ func ResetSchemaRegistry()

+ func SafeResolveURL(ctxURL, resURL string) (string, error)

+ func SetKeywordOrder(prop string, order int)

type AdditionalItems

+ func (ai *AdditionalItems) Register(uri string, registry *SchemaRegistry)

+ func (ai *AdditionalItems) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (ai *AdditionalItems) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type AdditionalProperties

+ func (ap *AdditionalProperties) Register(uri string, registry *SchemaRegistry)

+ func (ap *AdditionalProperties) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (ap *AdditionalProperties) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type AllOf

+ func (a *AllOf) Register(uri string, registry *SchemaRegistry)

+ func (a *AllOf) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (a *AllOf) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type Anchor string

+ func (a *Anchor) Register(uri string, registry *SchemaRegistry)

+ func (a *Anchor) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (a *Anchor) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type AnyOf

+ func (a *AnyOf) Register(uri string, registry *SchemaRegistry)

+ func (a *AnyOf) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (a *AnyOf) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type Comment string

+ func (c *Comment) Register(uri string, registry *SchemaRegistry)

+ func (c *Comment) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (c *Comment) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Const

+ func (c *Const) Register(uri string, registry *SchemaRegistry)

+ func (c *Const) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (c Const) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Contains

+ func (c *Contains) Register(uri string, registry *SchemaRegistry)

+ func (c *Contains) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (c *Contains) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type Default struct

+ func (d *Default) Register(uri string, registry *SchemaRegistry)

+ func (d *Default) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (d *Default) UnmarshalJSON(data []byte) error

+ func (d *Default) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type Defs map[string]*Schema

+ func (d *Defs) Register(uri string, registry *SchemaRegistry)

+ func (d *Defs) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (d Defs) JSONChildren() (res map[string]JSONPather)

+ func (d Defs) JSONProp(name string) interface{}

+ func (d Defs) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type DependentRequired map[string]PropertyDependency

+ func (d *DependentRequired) Register(uri string, registry *SchemaRegistry)

+ func (d *DependentRequired) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (d *DependentRequired) UnmarshalJSON(data []byte) error

+ func (d *DependentRequired) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ func (d DependentRequired) JSONChildren() (r map[string]JSONPather)

+ func (d DependentRequired) JSONProp(name string) interface{}

+ func (d DependentRequired) MarshalJSON() ([]byte, error)

+ type DependentSchemas map[string]SchemaDependency

+ func (d *DependentSchemas) Register(uri string, registry *SchemaRegistry)

+ func (d *DependentSchemas) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (d *DependentSchemas) UnmarshalJSON(data []byte) error

+ func (d *DependentSchemas) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ func (d DependentSchemas) JSONChildren() (r map[string]JSONPather)

+ func (d DependentSchemas) JSONProp(name string) interface{}

+ type Description string

+ func (d *Description) Register(uri string, registry *SchemaRegistry)

+ func (d *Description) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (d *Description) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Else

+ func (e *Else) Register(uri string, registry *SchemaRegistry)

+ func (e *Else) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (e *Else) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Enum

+ func (e *Enum) Register(uri string, registry *SchemaRegistry)

+ func (e *Enum) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (e Enum) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type Examples []interface

+ func (e *Examples) Register(uri string, registry *SchemaRegistry)

+ func (e *Examples) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (e *Examples) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type ExclusiveMaximum

+ func (m *ExclusiveMaximum) Register(uri string, registry *SchemaRegistry)

+ func (m *ExclusiveMaximum) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m ExclusiveMaximum) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type ExclusiveMinimum

+ func (m *ExclusiveMinimum) Register(uri string, registry *SchemaRegistry)

+ func (m *ExclusiveMinimum) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m ExclusiveMinimum) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Format

+ func (f *Format) Register(uri string, registry *SchemaRegistry)

+ func (f *Format) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (f Format) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type ID string

+ func (i *ID) Register(uri string, registry *SchemaRegistry)

+ func (i *ID) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (i *ID) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type If

+ func (f *If) Register(uri string, registry *SchemaRegistry)

+ func (f *If) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (f *If) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Items

+ func (it *Items) Register(uri string, registry *SchemaRegistry)

+ func (it *Items) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (it Items) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type KeyError struct

+ InvalidValue interface{}

+ Message string

+ PropertyPath string

+ func (v KeyError) Error() string

+ type KeyMaker func() Keyword

+ type Keyword interface

+ Register func(uri string, registry *SchemaRegistry)

+ Resolve func(pointer jptr.Pointer, uri string) *Schema

+ ValidateKeyword func(ctx context.Context, currentState *ValidationState, data interface{})

+ func GetKeyword(prop string) Keyword

+ func NewAnchor() Keyword

+ func NewComment() Keyword

+ func NewDefault() Keyword

+ func NewDefs() Keyword

+ func NewDependentRequired() Keyword

+ func NewDependentSchemas() Keyword

+ func NewDescription() Keyword

+ func NewExamples() Keyword

+ func NewID() Keyword

+ func NewMaxContains() Keyword

+ func NewMinContains() Keyword

+ func NewReadOnly() Keyword

+ func NewRecursiveAnchor() Keyword

+ func NewRecursiveRef() Keyword

+ func NewRef() Keyword

+ func NewSchema() Keyword

+ func NewSchemaURI() Keyword

+ func NewTitle() Keyword

+ func NewUnevaluatedItems() Keyword

+ func NewUnevaluatedProperties() Keyword

+ func NewVoid() Keyword

+ func NewWriteOnly() Keyword

+ type MaxContains int

+ func (m *MaxContains) Register(uri string, registry *SchemaRegistry)

+ func (m *MaxContains) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MaxContains) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type MaxItems

+ func (m *MaxItems) Register(uri string, registry *SchemaRegistry)

+ func (m *MaxItems) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MaxItems) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type MaxLength

+ func (m *MaxLength) Register(uri string, registry *SchemaRegistry)

+ func (m *MaxLength) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MaxLength) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type MaxProperties

+ func (m *MaxProperties) Register(uri string, registry *SchemaRegistry)

+ func (m *MaxProperties) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MaxProperties) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Maximum

+ func (m *Maximum) Register(uri string, registry *SchemaRegistry)

+ func (m *Maximum) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m Maximum) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type MinContains int

+ func (m *MinContains) Register(uri string, registry *SchemaRegistry)

+ func (m *MinContains) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MinContains) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type MinItems

+ func (m *MinItems) Register(uri string, registry *SchemaRegistry)

+ func (m *MinItems) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MinItems) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type MinLength

+ func (m *MinLength) Register(uri string, registry *SchemaRegistry)

+ func (m *MinLength) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MinLength) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type MinProperties int

+ func (m *MinProperties) Register(uri string, registry *SchemaRegistry)

+ func (m *MinProperties) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MinProperties) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Minimum

+ func (m *Minimum) Register(uri string, registry *SchemaRegistry)

+ func (m *Minimum) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m Minimum) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type MultipleOf

+ func (m *MultipleOf) Register(uri string, registry *SchemaRegistry)

+ func (m *MultipleOf) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (m MultipleOf) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Not

+ func (n *Not) Register(uri string, registry *SchemaRegistry)

+ func (n *Not) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (n *Not) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type OneOf

+ func (o *OneOf) Register(uri string, registry *SchemaRegistry)

+ func (o *OneOf) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (o *OneOf) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Pattern

+ func (p *Pattern) Register(uri string, registry *SchemaRegistry)

+ func (p *Pattern) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (p Pattern) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type PatternProperties

+ func (p *PatternProperties) Register(uri string, registry *SchemaRegistry)

+ func (p *PatternProperties) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (p PatternProperties) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Properties

+ func (p *Properties) Register(uri string, registry *SchemaRegistry)

+ func (p *Properties) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (p Properties) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type PropertyDependency struct

+ func (p *PropertyDependency) Register(uri string, registry *SchemaRegistry)

+ func (p *PropertyDependency) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (p *PropertyDependency) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ func (p PropertyDependency) JSONProp(name string) interface{}

type PropertyNames

+ func (p *PropertyNames) Register(uri string, registry *SchemaRegistry)

+ func (p *PropertyNames) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (p *PropertyNames) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type ReadOnly bool

+ func (r *ReadOnly) Register(uri string, registry *SchemaRegistry)

+ func (r *ReadOnly) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (r *ReadOnly) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type RecursiveAnchor Schema

+ func (r *RecursiveAnchor) Register(uri string, registry *SchemaRegistry)

+ func (r *RecursiveAnchor) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (r *RecursiveAnchor) UnmarshalJSON(data []byte) error

+ func (r *RecursiveAnchor) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type RecursiveRef struct

+ func (r *RecursiveRef) Register(uri string, registry *SchemaRegistry)

+ func (r *RecursiveRef) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (r *RecursiveRef) UnmarshalJSON(data []byte) error

+ func (r *RecursiveRef) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ func (r RecursiveRef) MarshalJSON() ([]byte, error)

+ type Ref struct

+ func (r *Ref) Register(uri string, registry *SchemaRegistry)

+ func (r *Ref) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (r *Ref) UnmarshalJSON(data []byte) error

+ func (r *Ref) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ func (r Ref) MarshalJSON() ([]byte, error)

type Required

+ func (r *Required) Register(uri string, registry *SchemaRegistry)

+ func (r *Required) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (r Required) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Schema

+ func (s *Schema) HasKeyword(key string) bool

+ func (s *Schema) Register(uri string, registry *SchemaRegistry)

+ func (s *Schema) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (s *Schema) TopLevelType() string

+ func (s *Schema) ValidateBytes(ctx context.Context, data []byte) ([]KeyError, error)

+ func (s *Schema) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type SchemaDependency struct

+ func (d *SchemaDependency) Register(uri string, registry *SchemaRegistry)

+ func (d *SchemaDependency) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (d *SchemaDependency) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ func (d SchemaDependency) JSONProp(name string) interface{}

+ func (d SchemaDependency) MarshalJSON() ([]byte, error)

+ type SchemaRegistry struct

+ func GetSchemaRegistry() *SchemaRegistry

+ func (sr *SchemaRegistry) Get(ctx context.Context, uri string) *Schema

+ func (sr *SchemaRegistry) GetKnown(uri string) *Schema

+ func (sr *SchemaRegistry) GetLocal(uri string) *Schema

+ func (sr *SchemaRegistry) Register(sch *Schema)

+ func (sr *SchemaRegistry) RegisterLocal(sch *Schema)

+ type SchemaURI string

+ func (s *SchemaURI) Register(uri string, registry *SchemaRegistry)

+ func (s *SchemaURI) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (s *SchemaURI) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Then

+ func (t *Then) Register(uri string, registry *SchemaRegistry)

+ func (t *Then) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (t *Then) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type Title string

+ func (t *Title) Register(uri string, registry *SchemaRegistry)

+ func (t *Title) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (t *Title) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type Type

+ func (t *Type) Register(uri string, registry *SchemaRegistry)

+ func (t *Type) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (t Type) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type UnevaluatedItems Schema

+ func (ui *UnevaluatedItems) Register(uri string, registry *SchemaRegistry)

+ func (ui *UnevaluatedItems) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (ui *UnevaluatedItems) UnmarshalJSON(data []byte) error

+ func (ui *UnevaluatedItems) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type UnevaluatedProperties Schema

+ func (up *UnevaluatedProperties) Register(uri string, registry *SchemaRegistry)

+ func (up *UnevaluatedProperties) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (up *UnevaluatedProperties) UnmarshalJSON(data []byte) error

+ func (up *UnevaluatedProperties) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

type UniqueItems

+ func (u *UniqueItems) Register(uri string, registry *SchemaRegistry)

+ func (u *UniqueItems) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (u UniqueItems) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type ValidationState struct

+ BaseRelativeLocation *jptr.Pointer

+ BaseURI string

+ Errs *[]KeyError

+ EvaluatedPropertyNames *map[string]bool

+ InstanceLocation *jptr.Pointer

+ LastEvaluatedIndex int

+ Local *Schema

+ LocalEvaluatedPropertyNames *map[string]bool

+ LocalLastEvaluatedIndex int

+ LocalRegistry *SchemaRegistry

+ Misc map[string]interface{}

+ RecursiveAnchor *Schema

+ RelativeLocation *jptr.Pointer

+ Root *Schema

+ func NewValidationState(s *Schema) *ValidationState

+ func (vs *ValidationState) AddError(data interface{}, msg string)

+ func (vs *ValidationState) AddSubErrors(errs ...KeyError)

+ func (vs *ValidationState) ClearState()

+ func (vs *ValidationState) DescendBase(token ...string)

+ func (vs *ValidationState) DescendBaseFromState(base *ValidationState, token ...string)

+ func (vs *ValidationState) DescendInstance(token ...string)

+ func (vs *ValidationState) DescendInstanceFromState(base *ValidationState, token ...string)

+ func (vs *ValidationState) DescendRelative(token ...string)

+ func (vs *ValidationState) DescendRelativeFromState(base *ValidationState, token ...string)

+ func (vs *ValidationState) IsEvaluatedKey(key string) bool

+ func (vs *ValidationState) IsLocallyEvaluatedKey(key string) bool

+ func (vs *ValidationState) IsValid() bool

+ func (vs *ValidationState) NewSubState() *ValidationState

+ func (vs *ValidationState) SetEvaluatedIndex(i int)

+ func (vs *ValidationState) SetEvaluatedKey(key string)

+ func (vs *ValidationState) UpdateEvaluatedPropsAndItems(subState *ValidationState)

+ type Void struct

+ func (vo *Void) Register(uri string, registry *SchemaRegistry)

+ func (vo *Void) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (vo *Void) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

+ type WriteOnly bool

+ func (w *WriteOnly) Register(uri string, registry *SchemaRegistry)

+ func (w *WriteOnly) Resolve(pointer jptr.Pointer, uri string) *Schema

+ func (w *WriteOnly) ValidateKeyword(ctx context.Context, currentState *ValidationState, data interface{})

v0.1.2

May 21, 2020

v0.1.1

Jun 3, 2019

v0.1.0

Jun 3, 2019

Changes in this version

+ var DefaultSchemaPool = Definitions

+ var DefaultValidators = map[string]ValMaker

+ var MaxValueErrStringLen = 20

+ func AddError(errs *[]ValError, propPath string, data interface{}, msg string)

+ func DataType(data interface{}) string

+ func InvalidValueString(data interface{}) string

+ func RegisterValidator(propName string, maker ValMaker)

+ type AdditionalItems struct

+ Schema *Schema

+ func (a *AdditionalItems) JSONChildren() (res map[string]JSONPather)

+ func (a *AdditionalItems) JSONProp(name string) interface{}

+ func (a *AdditionalItems) UnmarshalJSON(data []byte) error

+ func (a *AdditionalItems) Validate(propPath string, data interface{}, errs *[]ValError)

+ type AdditionalProperties struct

+ Properties *Properties

+ Schema *Schema

+ func (ap *AdditionalProperties) JSONChildren() (res map[string]JSONPather)

+ func (ap *AdditionalProperties) JSONProp(name string) interface{}

+ func (ap *AdditionalProperties) UnmarshalJSON(data []byte) error

+ func (ap AdditionalProperties) MarshalJSON() ([]byte, error)

+ func (ap AdditionalProperties) Validate(propPath string, data interface{}, errs *[]ValError)

+ type AllOf []*Schema

+ func (a AllOf) JSONChildren() (res map[string]JSONPather)

+ func (a AllOf) JSONProp(name string) interface{}

+ func (a AllOf) Validate(propPath string, data interface{}, errs *[]ValError)

+ type AnyOf []*Schema

+ func (a AnyOf) JSONChildren() (res map[string]JSONPather)

+ func (a AnyOf) JSONProp(name string) interface{}

+ func (a AnyOf) Validate(propPath string, data interface{}, errs *[]ValError)

+ type BaseValidator struct

+ func (b *BaseValidator) SetPath(path string)

+ func (b BaseValidator) AddError(errs *[]ValError, propPath string, data interface{}, msg string)

+ func (b BaseValidator) Path() string

+ type Const json.RawMessage

+ func (c *Const) UnmarshalJSON(data []byte) error

+ func (c Const) JSONProp(name string) interface{}

+ func (c Const) MarshalJSON() ([]byte, error)

+ func (c Const) Path() string

+ func (c Const) String() string

+ func (c Const) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Contains Schema

+ func (c *Contains) UnmarshalJSON(data []byte) error

+ func (c *Contains) Validate(propPath string, data interface{}, errs *[]ValError)

+ func (c Contains) JSONChildren() (res map[string]JSONPather)

+ func (c Contains) JSONProp(name string) interface{}

+ type Definitions map[string]*Schema

+ func (d Definitions) JSONChildren() (r map[string]JSONPather)

+ func (d Definitions) JSONProp(name string) interface{}

+ type Dependencies map[string]Dependency

+ func (d Dependencies) JSONProp(name string) interface{}

+ func (d Dependencies) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Dependency struct

+ func (d *Dependency) UnmarshalJSON(data []byte) error

+ func (d Dependency) MarshalJSON() ([]byte, error)

+ func (d Dependency) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Else Schema

+ func (e *Else) UnmarshalJSON(data []byte) error

+ func (e *Else) Validate(propPath string, data interface{}, err *[]ValError)

+ func (e Else) JSONChildren() (res map[string]JSONPather)

+ func (e Else) JSONProp(name string) interface{}

+ func (e Else) MarshalJSON() ([]byte, error)

+ type Enum []Const

+ func (e Enum) JSONChildren() (res map[string]JSONPather)

+ func (e Enum) JSONProp(name string) interface{}

+ func (e Enum) Path() string

+ func (e Enum) String() string

+ func (e Enum) Validate(propPath string, data interface{}, errs *[]ValError)

+ type ExclusiveMaximum float64

+ func (m ExclusiveMaximum) Validate(propPath string, data interface{}, errs *[]ValError)

+ type ExclusiveMinimum float64

+ func (m ExclusiveMinimum) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Format string

+ func (f Format) Validate(propPath string, data interface{}, errs *[]ValError)

+ type If struct

+ Else *Else

+ Schema Schema

+ Then *Then

+ func (i *If) UnmarshalJSON(data []byte) error

+ func (i *If) Validate(propPath string, data interface{}, errs *[]ValError)

+ func (i If) JSONChildren() (res map[string]JSONPather)

+ func (i If) JSONProp(name string) interface{}

+ func (i If) MarshalJSON() ([]byte, error)

+ type Items struct

+ Schemas []*Schema

+ func (it *Items) UnmarshalJSON(data []byte) error

+ func (it Items) JSONChildren() (res map[string]JSONPather)

+ func (it Items) JSONProp(name string) interface{}

+ func (it Items) MarshalJSON() ([]byte, error)

+ func (it Items) Validate(propPath string, data interface{}, errs *[]ValError)

+ type JSONContainer interface

+ JSONChildren func() map[string]JSONPather

+ type JSONPather interface

+ JSONProp func(name string) interface{}

+ type MaxItems int

+ func (m MaxItems) Validate(propPath string, data interface{}, errs *[]ValError)

+ type MaxLength int

+ func (m MaxLength) Validate(propPath string, data interface{}, errs *[]ValError)

+ type MaxProperties int

+ func (m MaxProperties) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Maximum float64

+ func (m Maximum) Validate(propPath string, data interface{}, errs *[]ValError)

+ type MinItems int

+ func (m MinItems) Validate(propPath string, data interface{}, errs *[]ValError)

+ type MinLength int

+ func (m MinLength) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Minimum float64

+ func (m Minimum) Validate(propPath string, data interface{}, errs *[]ValError)

+ type MultipleOf float64

+ func (m MultipleOf) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Not Schema

+ func (n *Not) UnmarshalJSON(data []byte) error

+ func (n *Not) Validate(propPath string, data interface{}, errs *[]ValError)

+ func (n Not) JSONChildren() (res map[string]JSONPather)

+ func (n Not) JSONProp(name string) interface{}

+ func (n Not) MarshalJSON() ([]byte, error)

+ type OneOf []*Schema

+ func (o OneOf) JSONChildren() (res map[string]JSONPather)

+ func (o OneOf) JSONProp(name string) interface{}

+ func (o OneOf) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Pattern regexp.Regexp

+ func (p *Pattern) UnmarshalJSON(data []byte) error

+ func (p Pattern) MarshalJSON() ([]byte, error)

+ func (p Pattern) Validate(propPath string, data interface{}, errs *[]ValError)

+ type PatternProperties []patternSchema

+ func (p *PatternProperties) UnmarshalJSON(data []byte) error

+ func (p PatternProperties) JSONChildren() (res map[string]JSONPather)

+ func (p PatternProperties) JSONProp(name string) interface{}

+ func (p PatternProperties) MarshalJSON() ([]byte, error)

+ func (p PatternProperties) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Properties map[string]*Schema

+ func (p Properties) JSONChildren() (res map[string]JSONPather)

+ func (p Properties) JSONProp(name string) interface{}

+ func (p Properties) Validate(propPath string, data interface{}, errs *[]ValError)

+ type PropertyNames Schema

+ func (p *PropertyNames) UnmarshalJSON(data []byte) error

+ func (p PropertyNames) JSONChildren() (res map[string]JSONPather)

+ func (p PropertyNames) JSONProp(name string) interface{}

+ func (p PropertyNames) MarshalJSON() ([]byte, error)

+ func (p PropertyNames) Validate(propPath string, data interface{}, errs *[]ValError)

+ type Required []string

+ func (r Required) JSONProp(name string) interface{}

+ func (r Required) Validate(propPath string, data interface{}, errs *[]ValError)

+ type RootSchema struct

+ SchemaURI string

+ func Must(jsonString string) *RootSchema

+ func (rs *RootSchema) FetchRemoteReferences() error

+ func (rs *RootSchema) TopLevelType() string

+ func (rs *RootSchema) UnmarshalJSON(data []byte) error

+ func (rs *RootSchema) ValidateBytes(data []byte) ([]ValError, error)

+ type Schema struct

+ Comment string

+ Default interface{}

+ Definitions Definitions

+ Description string

+ Examples []interface{}

+ Format string

+ ID string

+ ReadOnly *bool

+ Ref string

+ Title string

+ Validators map[string]Validator

+ WriteOnly *bool

+ func (s *Schema) Path() string

+ func (s *Schema) UnmarshalJSON(data []byte) error

+ func (s *Schema) Validate(propPath string, data interface{}, errs *[]ValError)

+ func (s Schema) JSONChildren() (ch map[string]JSONPather)

+ func (s Schema) JSONProp(name string) interface{}

+ func (s Schema) MarshalJSON() ([]byte, error)

+ type Then Schema

+ func (t *Then) UnmarshalJSON(data []byte) error

+ func (t *Then) Validate(propPath string, data interface{}, errs *[]ValError)

+ func (t Then) JSONChildren() (res map[string]JSONPather)

+ func (t Then) JSONProp(name string) interface{}

+ func (t Then) MarshalJSON() ([]byte, error)

+ type Type struct

+ func (t *Type) UnmarshalJSON(data []byte) error

+ func (t Type) JSONProp(name string) interface{}

+ func (t Type) MarshalJSON() ([]byte, error)

+ func (t Type) String() string

+ func (t Type) Validate(propPath string, data interface{}, errs *[]ValError)

+ type UniqueItems bool

+ func (u *UniqueItems) Validate(propPath string, data interface{}, errs *[]ValError)

+ type ValError struct

+ InvalidValue interface{}

+ Message string

+ PropertyPath string

+ RulePath string

+ func (v ValError) Error() string

+ type ValMaker func() Validator

+ type Validator interface

+ Validate func(propPath string, data interface{}, errs *[]ValError)

+ func NewAdditionalItems() Validator

+ func NewAdditionalProperties() Validator

+ func NewAllOf() Validator

+ func NewAnyOf() Validator

+ func NewConst() Validator

+ func NewContains() Validator

+ func NewDependencies() Validator

+ func NewElse() Validator

+ func NewEnum() Validator

+ func NewExclusiveMaximum() Validator

+ func NewExclusiveMinimum() Validator

+ func NewFormat() Validator

+ func NewIf() Validator

+ func NewItems() Validator

+ func NewMaxItems() Validator

+ func NewMaxLength() Validator

+ func NewMaxProperties() Validator

+ func NewMaximum() Validator

+ func NewMinItems() Validator

+ func NewMinLength() Validator

+ func NewMinProperties() Validator

+ func NewMinimum() Validator

+ func NewMultipleOf() Validator

+ func NewNot() Validator

+ func NewOneOf() Validator

+ func NewPattern() Validator

+ func NewPatternProperties() Validator

+ func NewProperties() Validator

+ func NewPropertyNames() Validator

+ func NewRequired() Validator

+ func NewThen() Validator

+ func NewType() Validator

+ func NewUniqueItems() Validator

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL