vcr

type Ambassador interface {
	// Configure instructs the ambassador to start receiving DID Documents from the network.
	Configure()
}

type ConceptFinder interface {
	// Get returns the requested concept as concept.Concept for the subject or ErrNotFound
	// It also returns untrusted credentials when allowUntrusted == true
	Get(conceptName string, allowUntrusted bool, subject string) (concept.Concept, error)

	// SearchConcept returns matching concepts based upon a query. It returns an empty list if no matches have been found.
	// It also returns untrusted credentials when allowUntrusted == true
	// a context must be passed to prevent long-running queries
	SearchConcept(ctx context.Context, conceptName string, allowUntrusted bool, query map[string]string) ([]concept.Concept, error)
}

type Config struct {

	// OverrideAllPublic overrides the "Public" property of a credential when issuing credentials:
	// if set to true, all issued credentials are published as public credentials, regardless of whether they're actually marked as public.
	OverrideIssueAllPublic bool `koanf:"vcr.overrideissueallpublic"`
	// contains filtered or unexported fields
}

type Finder interface {
	// Search for matching VCs based upon a query. It returns an empty list if no matches have been found.
	// It also returns untrusted credentials when allowUntrusted == true
	// a context must be passed to prevent long-running queries
	Search(ctx context.Context, query concept.Query, allowUntrusted bool, resolveTime *time.Time) ([]vc.VerifiableCredential, error)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Resolver interface {
	// Registry returns the concept registry as read-only
	Registry() concept.Reader
	// Resolve returns a credential based on its ID.
	// The optional resolveTime will resolve the credential at that point in time.
	// The credential will still be returned in the case of ErrRevoked and ErrUntrusted.
	// For other errors, nil is returned
	Resolve(ID ssi.URI, resolveTime *time.Time) (*vc.VerifiableCredential, error)
}

type TrustManager interface {
	// Trust adds trust for a Issuer/CredentialType combination.
	Trust(credentialType ssi.URI, issuer ssi.URI) error
	// Untrust removes trust for a Issuer/CredentialType combination.
	Untrust(credentialType ssi.URI, issuer ssi.URI) error
	// Trusted returns a list of trusted issuers for given credentialType
	Trusted(credentialType ssi.URI) ([]ssi.URI, error)
	// Untrusted returns a list of untrusted issuers based on known credentials
	Untrusted(credentialType ssi.URI) ([]ssi.URI, error)
}

type VCR interface {
	Issuer() issuer.Issuer
	Holder() holder.Holder
	Verifier() verifier.Verifier

	// Issue creates and publishes a new VC.
	// An optional expirationDate can be given.
	// VCs are stored when the network has successfully published them.
	Issue(vcToIssue vc.VerifiableCredential) (*vc.VerifiableCredential, error)
	// Revoke a credential based on its ID, the Issuer will be resolved automatically.
	// The statusDate will be set to the current time.
	// It returns an error if the credential, issuer or private key can not be found.
	Revoke(ID ssi.URI) (*credential.Revocation, error)

	Finder
	ConceptFinder
	Resolver
	TrustManager
	Validator
	Writer
}

type Validator interface {
	// Validate checks if the given credential:
	// - is not revoked
	// - is valid at the given time (or now if not give)
	// - has a valid issuer
	// - has a valid signature if checkSignature is true
	// if allowUntrusted == false, the issuer must also be a trusted DID
	// May return ErrRevoked, ErrUntrusted or ErrInvalidPeriod
	Validate(credential vc.VerifiableCredential, allowUntrusted bool, checkSignature bool, validAt *time.Time) error
}

type Writer interface {
	// StoreCredential writes a VC to storage. Before writing, it calls Verify!
	// It can handle duplicates.
	StoreCredential(vc vc.VerifiableCredential, validAt *time.Time) error
	// StoreRevocation writes a revocation to storage.
	StoreRevocation(r credential.Revocation) error
}