services

type ContractFormat string

type ContractNotary interface {
	contract.VPVerifier

	// DrawUpContract draws up a contract from a template and returns a Contract which than can be signed by the user.
	DrawUpContract(ctx context.Context, template contract.Template, orgID did.DID, validFrom time.Time, validDuration time.Duration, organizationCredential *vc.VerifiableCredential) (*contract.Contract, error)

	// CreateSigningSession creates a signing session for the requested contract and means
	CreateSigningSession(sessionRequest CreateSessionRequest) (contract.SessionPointer, error)

	// SigningSessionStatus returns the status of the current signing session or ErrSessionNotFound is sessionID is unknown
	// context is used to pass audit context when using crypto library
	SigningSessionStatus(ctx context.Context, sessionID string) (contract.SigningSessionResult, error)

	Configure() error

	core.Routable
}

type ContractValidationResult struct {
	ValidationResult ValidationState `json:"validation_result"`
	FailureReason    string          `json:"failure_reason"`
	ContractFormat   ContractFormat  `json:"contract_format"`
	// DisclosedAttributes contain the attributes used to sign this contract
	DisclosedAttributes map[string]string `json:"disclosed_attributes"`
	// ContractAttributes contain the attributes used to fill the contract
	ContractAttributes map[string]string `json:"contract_attributes"`
}

type CreateAccessTokenRequest struct {
	RawJwtBearerToken string
}

type CreateJwtGrantRequest struct {
	Requester   string
	Authorizer  string
	IdentityVP  *vc.VerifiablePresentation
	Service     string
	Credentials []vc.VerifiableCredential
}

type CreateSessionRequest struct {
	SigningMeans string
	// Message to sign
	Message string
	// Params contain means specific parameters
	Params map[string]interface{}
}

type CreateSessionResult struct {
	QrCodeInfo irma.Qr
	SessionID  string
}

type InvalidContractRequestError struct {
	Message interface{}
}

type JwtBearerTokenResult struct {
	BearerToken                 string
	AuthorizationServerEndpoint string
}

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

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

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

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

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

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

type NutsAccessToken struct {
	Service        string  `json:"service"`
	Initials       *string `json:"initials,omitempty"`
	Prefix         *string `json:"prefix,omitempty"`
	FamilyName     *string `json:"family_name,omitempty"`
	Email          *string `json:"email,omitempty"`
	AssuranceLevel *string `json:"assurance_level,omitempty"`
	Username       *string `json:"username,omitempty"`
	UserRole       *string `json:"user_role,omitempty"`

	KeyID       string   `json:"-"`
	Expiration  int64    `json:"exp"`
	IssuedAt    int64    `json:"iat"`
	Issuer      string   `json:"iss"`
	Subject     string   `json:"sub"`
	Audience    string   `json:"aud"`
	Credentials []string `json:"vcs,omitempty"`
}

type NutsIdentityToken struct {
	// KeyID identifies the key that was used to sign the token
	KeyID string `json:"kid"`
	// What kind of signature? Currently only IRMA is supported
	Type ContractFormat `json:"type"`
	// The base64 encoded signature
	Signature string `json:"sig"`
}

type SessionID string

type SignedToken interface {
	// SignerAttributes extracts a map of attribute names and their values from the signature
	SignerAttributes() (map[string]string, error)
	// Contract extracts the Contract from the SignedToken
	Contract() contract.Contract
}

type TestVPVerificationResult struct {
	Val           contract.State
	FailureReason string
	Type          string
	DAttributes   map[string]string
	CAttributes   map[string]string
}

type VPProofValueParser interface {
	// Parse accepts a raw ProofValue from the VP as a string. The parser tries to parse the value into a SignedToken.
	Parse(rawAuthToken string) (SignedToken, error)

	// Verify accepts a SignedToken and verifies the signature using the crypto for the specific implementation of this interface.
	Verify(token SignedToken) error
}

type ValidationState string