didsubject

type CreationOption interface {
}

type CreationOptions interface {
	// With adds an option to the CreationOptions.
	// It returns a new CreationOptions instance.
	// If the same option is specified multiple times, the last instance will be used.
	With(option CreationOption) CreationOptions
	// All returns all the options.
	All() []CreationOption
}

type DIDDocumentManager interface {
	// CreateOrUpdate adds a new version of a DID document, starts at 1
	// If the DID does not exist yet, it will be created
	// It adds all verification methods and services to the DID document
	// Not passing any verification methods will create an empty DID document, deactivation checking should be done by the caller
	CreateOrUpdate(did orm.DID, verificationMethods []orm.VerificationMethod, services []orm.Service) (*orm.DidDocument, error)
	// Latest returns the latest version of a DID document
	// if notAfter is given, it will return the latest version before that time
	Latest(did did.DID, notAfter *time.Time) (*orm.DidDocument, error)
}

type DIDManager interface {
	// Add adds a new DID to the database, this is also done via DIDDocumentManager.CreateOrUpdate
	Add(subject string, did did.DID) (*orm.DID, error)
	// All returns all DIDs in the database
	All() ([]orm.DID, error)
	// Delete removes a DID from the database
	Delete(did did.DID) error
	// DeleteAll removes all DIDs for a subject from the database
	DeleteAll(subject string) error
	// Find returns a DID by its ID
	Find(id did.DID) (*orm.DID, error)
	// FindBySubject returns all DIDs for a subject
	FindBySubject(subject string) ([]orm.DID, error)
}

type DocumentManager interface {
	// Update replaces the DID document identified by DID with the nextVersion
	// Deprecated: only did:nuts implements it, new methods should higher level functions, then this method can become private
	// If the DID Document is not found, ErrNotFound is returned
	// If the DID Document is not managed by this node, ErrDIDNotManagedByThisNode is returned
	Update(ctx context.Context, id did.DID, next did.Document) error

	// RemoveVerificationMethod removes a VerificationMethod from a DID document.
	// Deprecated: only relevant for v1 API calls.
	// It accepts the id DID as identifier for the DID document.
	// It accepts the kid DID as identifier for the VerificationMethod.
	// It returns an ErrNotFound when the DID document could not be found.
	// It returns an ErrNotFound when there is no VerificationMethod with the provided kid in the document.
	// It returns an ErrDeactivated when the DID document has the deactivated state.
	// It returns an ErrDIDNotManagedByThisNode if the DID document is not managed by this node.
	RemoveVerificationMethod(ctx context.Context, id did.DID, keyID did.DIDURL) error
}

type DocumentMigration interface {
	// MigrateDIDHistoryToSQL is used to migrate the history of a DID Document to SQL.
	// It adds all versions of a DID Document up to a deactivated version. Any changes after a deactivation are not migrated.
	// getHistory retrieves the history of the DID since the requested version.
	MigrateDIDHistoryToSQL(id did.DID, subject string, getHistory func(id did.DID, sinceVersion int) ([]orm.MigrationDocument, error)) error
	// MigrateAddWebToNuts checks if the provided did:nuts DID adds a did:web DID under the same subject if does not already have one.
	// It does not check that id is a did:nuts DID
	MigrateAddWebToNuts(ctx context.Context, id did.DID) error
}

type DocumentOwner interface {
	// IsOwner returns true if the DID Document is owned by the node, meaning there are private keys present for the DID Document.
	IsOwner(context.Context, did.DID) (bool, error)
	// ListOwned returns all the DIDs owned by the node.
	ListOwned(ctx context.Context) ([]did.DID, error)
}

type EncryptionKeyCreationOption struct{}

type Manager interface {
	// Create creates a new DID document for each method and returns them.
	// The DID subject is also returned
	Create(ctx context.Context, options CreationOptions) ([]did.Document, string, error)

	// Deactivate deactivates DID documents for a subject, making it unusable for future interactions.
	// If no documents are found, an error is returned.
	Deactivate(ctx context.Context, subject string) error

	// List returns all subjects and their DIDs.
	List(ctx context.Context) (map[string][]did.DID, error)

	// ListDIDs returns all DIDs for a subject
	ListDIDs(ctx context.Context, subject string) ([]did.DID, error)

	// Exists returns true if the subject exists
	Exists(ctx context.Context, subject string) (bool, error)

	// CreateService creates a new service in DID documents for the given subject.
	// The service ID will be generated.
	CreateService(ctx context.Context, subject string, service did.Service) ([]did.Service, error)

	// FindServices returns services for a given subject matching type if given.
	// Duplicate services (based on ID) are ignored.
	FindServices(ctx context.Context, subject string, serviceType *string) ([]did.Service, error)

	// UpdateService updates a service in the DID document identified by serviceID.
	// It'll match any service for the subject based on the fragment. This allows for updating services across multiple DID methods.
	UpdateService(ctx context.Context, subject string, serviceID ssi.URI, service did.Service) ([]did.Service, error)

	// DeleteService deletes services in the DID documents for a given subject.
	// It'll match any service for the subject based on the fragment.
	// It returns an error if no services have been deleted.
	DeleteService(ctx context.Context, subject string, serviceID ssi.URI) error

	// AddVerificationMethod generates new keys and adds them, wrapped as a VerificationMethod, to all DID documents of a subject.
	// For each DID method a new key will be generated.
	// It returns an ErrNotFound when the subject could not be found.
	// It returns an ErrDeactivated when the subject has the deactivated state.
	AddVerificationMethod(ctx context.Context, subject string, keyUsage orm.DIDKeyFlags) ([]did.VerificationMethod, error)

	// Rollback queries the did_change_log table for all changes that are older than 1 minute.
	// Any entry that's still there is considered not committed and will be rolled back.
	// All DID Document versions that are part of the same transaction_id will be deleted.
	// This works because did:web is always committed and did:nuts might not be. So the DB state actually only depends on the result of the did:nuts network operation result.
	Rollback(ctx context.Context)
}

type MethodManager interface {
	// NewDocument generates a new DID document for the given subject.
	// This is done by the method manager since the DID might depend on method specific rules.
	// keyFlags is a hard requirement, same as NewVerificationMethod's.
	NewDocument(ctx context.Context, keyFlags orm.DIDKeyFlags) (*orm.DidDocument, error)
	// NewVerificationMethod generates a new VerificationMethod for the given subject.
	// This is done by the method manager since the VM ID might depend on method specific rules.
	// keyFlags is a hard requirement: if the underlying key store backend can't back every requested
	// usage for the generated key (e.g. an Azure Key Vault EC key can sign but can't back
	// KeyAgreement, since Azure Key Vault doesn't support decryption/ECDH with it), no key is created
	// and an error is returned.
	NewVerificationMethod(ctx context.Context, controller did.DID, keyFlags orm.DIDKeyFlags) (*did.VerificationMethod, error)
	// Commit is called after changes are made to the primary db.
	// On success, the caller will remove/update the DID changelog.
	Commit(ctx context.Context, event orm.DIDChangeLog) error
	// IsCommitted checks if the event is already committed for the specific method.
	// A mismatch can occur if the method commits before the db is updated (db failure).
	// If a change is not committed, a rollback of the primary db will occur (delete of that version)
	IsCommitted(ctx context.Context, event orm.DIDChangeLog) (bool, error)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type NutsLegacyNamingOption struct{}

type Resolver struct {
	DB *gorm.DB
}

type SkipAssertionKeyCreationOption struct{}

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

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

type SqlManager struct {
	DB             *gorm.DB
	MethodManagers map[string]MethodManager
	KeyStore       nutsCrypto.KeyStore
	// PreferredOrder is the order in which the methods are preferred, which dictates the order in which they are returned.
	PreferredOrder []string
}

type SubjectCreationOption struct {
	Subject string
}