signing

type ArrayExcludes struct {
	Continue ExcludeRules
}

type ConditionalArrayExcludes struct {
	ValueChecker  ValueChecker
	ValueMapper   ValueMapper
	ContinueTrue  ExcludeRules
	ContinueFalse ExcludeRules
}

type ConditionalExclude struct {
	ValueChecker  ValueChecker
	ValueMapper   ValueMapper
	ContinueTrue  ExcludeRules
	ContinueFalse ExcludeRules
	Name          string
}

type ConditionalMapExcludes map[string]*ConditionalExclude

type DefaultedListEntries struct {
	Default  interface{}
	Continue ExcludeRules
	Next     ExcludeRules
}

type DefaultedMapFields struct {
	// Name of the field for map entries, for lists this field must be left blank.
	Name     string
	Fields   map[string]interface{}
	Continue ExcludeRules
	Next     ExcludeRules
}

type DynamicArrayExcludes struct {
	ValueChecker ValueChecker
	ValueMapper  ValueMapper
	Continue     ExcludeRules
}

type DynamicExclude struct {
	ValueChecker ValueChecker
	ValueMapper  ValueMapper
	Continue     ExcludeRules
	Name         string
}

type DynamicInclude struct {
	ValueChecker ValueChecker
	ValueMapper  ValueMapper
	Continue     ExcludeRules
	Name         string
}

type DynamicMapExcludes map[string]*DynamicExclude

type DynamicMapIncludes map[string]*DynamicInclude

type ExcludeEmpty struct {
	ExcludeRules
}

type ExcludeRules interface {
	Field(name string, value interface{}) (string, interface{}, ExcludeRules)
	Element(v interface{}) (bool, interface{}, ExcludeRules)
}

type HandlerRegistry interface {
	RegisterSignatureHandler(handler SignatureHandler)
	RegisterSigner(algo string, signer Signer)
	RegisterVerifier(algo string, verifier Verifier)
	GetSigner(name string) Signer
	GetVerifier(name string) Verifier
	SignerNames() []string

	RegisterHasher(hasher Hasher)
	GetHasher(name string) Hasher
	HasherNames() []string
}

type Hasher interface {
	Algorithm() string
	Create() hash.Hash
	Crypto() crypto.Hash
}

type KeyRegistry interface {
	RegisterPublicKey(name string, key interface{})
	RegisterPrivateKey(name string, key interface{})
	GetPublicKey(name string) interface{}
	GetPrivateKey(name string) interface{}
}

type MapExcludes map[string]ExcludeRules

type MapIncludes map[string]ExcludeRules

type NoExcludes struct{}

type Normalization interface {
	NewArray() Normalized
	NewMap() Normalized
	NewValue(v interface{}) Normalized

	String() string
}

type NormalizationFilter interface {
	Filter(Normalized) (Normalized, error)
}

type Normalized interface {
	Value() interface{}
	IsEmpty() bool
	Marshal(gap string) ([]byte, error)

	ToString(gap string) string
	String() string
	Formatted() string

	Append(Normalized)
	SetField(name string, value Normalized)
}

type Registry interface {
	HandlerRegistry
	KeyRegistry
}

type Signature struct {
	Value     string
	MediaType string
	Algorithm string
	Issuer    string
}

type SignatureHandler interface {
	Algorithm() string
	Signer
	Verifier
}

type Signer interface {
	// Sign returns the signature for the given digest
	Sign(cctx credentials.Context, digest string, hash crypto.Hash, issuer string, privatekey interface{}) (*Signature, error)
	// Algorithm is the name of the finally used signature algorithm.
	// A signer might be registered using a logical name, so there might
	// be multiple signer registration providing the same signature algorithm
	Algorithm() string
}

type ValueChecker func(value interface{}) bool

type ValueMapper func(v interface{}) interface{}

type Verifier interface {
	// Verify checks the signature, returns an error on verification failure
	Verify(digest string, hash crypto.Hash, sig *Signature, publickey interface{}) error
	Algorithm() string
}