resolver

type ChainedDIDResolver struct {
	Resolvers []DIDResolver
}

type DIDKeyResolver struct {
	Resolver DIDResolver
}

type DIDResolver interface {
	// Resolve returns a DID Document for the provided DID.
	// If metadata is not provided the latest version is returned.
	// If metadata is provided then the result is filtered or scoped on that metadata.
	// It returns ErrNotFound if there are no corresponding DID documents or when the DID Documents are disjoint with the provided ResolveMetadata
	// It returns ErrDeactivated if the DID Document has been deactivated and metadata is unset or metadata.AllowDeactivated is false.
	// It returns ErrNoActiveController if all of the DID Documents controllers have been deactivated and metadata is unset or metadata.AllowDeactivated is false.
	Resolve(id did.DID, metadata *ResolveMetadata) (*did.Document, *DocumentMetadata, error)
}

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

type DIDServiceResolver struct {
	Resolver DIDResolver
}

type DocFinder interface {
	Find(...Predicate) ([]did.Document, error)
}

type DocIterator func(doc did.Document, metadata DocumentMetadata) error

type DocumentMetadata struct {
	Created time.Time  `json:"created"`
	Updated *time.Time `json:"updated,omitempty"`
	// Hash of DID document bytes. Is equal to payloadHash in network layer.
	Hash hash.SHA256Hash `json:"hash"`
	// PreviousHash of the previous version of this DID document
	PreviousHash *hash.SHA256Hash `json:"previousHash,omitempty"`
	// SourceTransactions points to the transaction(s) that created the current version of this DID Document.
	// If multiple transactions are listed, the DID Document is conflicted
	SourceTransactions []hash.SHA256Hash `json:"txs"`
	// Deactivated indicates if the document is deactivated
	Deactivated bool `json:"deactivated"`
}

type KeyResolver interface {
	// ResolveKeyByID looks up a specific key of the given RelationType and returns it as crypto.PublicKey.
	// If multiple keys are valid, the first one is returned.
	// An ErrKeyNotFound is returned when no key (of the specified type) is found.
	ResolveKeyByID(keyID string, metadata *ResolveMetadata, relationType RelationType) (crypto.PublicKey, error)
	// ResolveKey looks for a valid key of the given RelationType for the given DID, and returns its ID as string and the public key.
	// If multiple keys are valid, the first one is returned.
	// An ErrKeyNotFound is returned when no key (of the specified type) is found.
	ResolveKey(id did.DID, validAt *time.Time, relationType RelationType) (string, crypto.PublicKey, error)
}

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

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

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

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

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

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

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

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

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

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

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

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

type NutsKeyResolver interface {
	// ResolvePublicKey loads the key from a DID Document where the DID Document
	// was created with one of the given tx refs
	// It returns ErrKeyNotFound when the key could not be found in the DID Document.
	// It returns ErrNotFound when the DID Document can't be found.
	ResolvePublicKey(kid string, sourceTransactionsRefs []hash.SHA256Hash) (crypto.PublicKey, error)
}

type Predicate interface {
	// Match returns true if the given DID Document passes the predicate condition
	Match(did.Document, DocumentMetadata) bool
}

type RelationType uint

type ResolveMetadata struct {
	// Resolve the version which is valid at this time
	ResolveTime *time.Time
	// if provided, use the version which matches this exact hash
	Hash *hash.SHA256Hash
	// SourceTransaction must match a TX hash from the metadata.SourceTransaction field, if provided
	SourceTransaction *hash.SHA256Hash
	// Allow DIDs which are deactivated
	AllowDeactivated bool
	// JWT protected headers
	JwtProtectedHeaders map[string]interface{}
}

type ServiceQueryError struct {
	Err error // cause
}

type ServiceResolver interface {
	// Resolve looks up the DID document of the specified query and then tries to find the service with the specified type.
	// The query must be in the form of a service query, e.g. `did:nuts:12345/serviceEndpoint?type=some-type`.
	// The maxDepth indicates how deep references are followed. If maxDepth = 0, no references are followed (and an error is returned if the given query resolves to a reference).
	// If the DID document or service is not found, a reference can't be resolved or the references exceed maxDepth, an error is returned.
	Resolve(query ssi.URI, maxDepth int) (did.Service, error)

	// ResolveEx tries to resolve a DID service from the given endpoint URI, following references (URIs that begin with 'did:').
	// When the endpoint is a reference it resolves it up until the (per spec) max reference depth. When resolving a reference it recursively calls itself with depth + 1.
	// The documentCache map is used to avoid resolving the same document over and over again, which might be a (slightly more) expensive operation.
	ResolveEx(endpoint ssi.URI, depth int, maxDepth int, documentCache map[string]*did.Document) (did.Service, error)
}