openidvc

type AuthorizationDetails struct {
	Type                 string           `json:"type"`
	Format               string           `json:"format"`
	CredentialTypes      []CredentialType `json:"types"`
	CredentialDefinition string           `json:"credential_definition"`
}

type AuthorizationRequest struct {
	// scope is required
	Scope string `schema:"scope"`
	// response_type is required
	ResponseType ResponseType `schema:"response_type"`
	//client_id is required
	ClientId string `schema:"client_id"`
	// redirect_uri is required
	RedirectUri string `schema:"redirect_uri"`
	// state is recommended
	State string `schema:"state,omitempty"`
	// code_challenge is required, rfc 7636
	CodeChallenge       string              `schema:"code_challenge,omitempty"`
	CodeChallengeMethod CodeChallengeMethod `schema:"code_challenge_method,omitempty"`
	// not required because authorization_details is one way to request a credential, the other one is to use scope
	AuthorizationDetails string `schema:"authorization_details,omitempty"`
	// rfc 9126, OAuth 2.0 Pushed Authorization Requests
	RequestUri string `schema:"request_uri,omitempty"`
	// open id for presentations
	PresentDef    string `schema:"presentation_definition,omitempty"`
	PresentDefUri string `schema:"presentation_definition_uri,omitempty"`
	// nonce is required for presentation of the credential
	Nonce string `schema:"nonce,omitempty"`
}

type AuthorizationResponse struct {
	// code is required when response type is token
	Code  string `schema:"code,omitempty"`
	State string `schema:"state,omitempty"`
	// parameters for the presentation response
	PresentationToken string `schema:"vp_token,omitempty"`
	IdentityToken     string `schema:"id_token,omitempty"`
	PresentSubmission string `schema:"presentation_submission,omitempty"`
}

type ClientMetadata map[string]interface{}

type CodeChallengeMethod string

type CredentialFormat string

type CredentialRequest struct {
	ClientId             string           `json:"client_id"`
	AuthorizationDetails string           `json:"authorization_details"`
	CNonce               string           `json:"c_nonce"`
	CNonceExpiresIn      time.Duration    `json:"c_nonce_expires_in"`
	BearerTokenSHA512    [64]byte         `json:"token_hash"`
	BearerTokenExpiresIn time.Duration    `json:"token_type"`
	Deferred             bool             `json:"deferred"`
	Format               CredentialFormat `json:"format"`
	// object containing the proof of posession of the did
	Proof ProofOfPossession `json:"proof"`
	// the following two attriutes are according to appendix E of the open id specification
	CredentialTypes      []string        `json:"types"`
	CredentialDefinition json.RawMessage `json:"credential_definition"`
}

type CredentialResponse struct {
	Format          CredentialFormat `json:"format"`
	Credential      string           `json:"credential"`
	AcceptanceToken string           `json:"acceptance_token"`
	CNonce          string           `json:"c_nonce"`
	CNonceExpiresIn time.Duration    `json:"c_nonce_expires_in"`
}

type CredentialResponseOption func(*optionalParameters)

type CredentialSubject interface{}

type CredentialType string

type DecetralizedIdentifier interface {
	ResolveDid(did string) (interface{}, error)
}

type DescriptorMap struct {
	Id         string     `json:"id"`
	Format     string     `json:"format"`
	Path       string     `json:"path"`
	PathNested PathNested `json:"path_nested"`
}

type ErrorResponse struct {
	Error            string `json:"error"`
	ErrorDescription string `json:"error_description,omitempty"`
	ErrorUri         string `json:"error_uri,omitempty"`
}

type GrantType string

type Issuer interface {
	// NewCredentialRequest receives an open id for credential issuance request
	// the options must contain the signing key of the access token
	NewCredentialRequest(r *http.Request, options ...TokenResponseOption) (CredentialRequest, error)
	// NewDeferredCredentialRequest receives a issuance request for a deferred credential
	NewDeferredCredentialRequest(r *http.Request, options ...TokenResponseOption) (CredentialRequest, error)
}

type MKVStore struct {
	*buntdb.DB
}

type Metadata struct {
	Versions         map[string]float32 `mapstructure:"versions"`
	ServerConfig     ServerConfig       `mapstructure:"config"`
	ProviderMetadata ProviderMetadata   `mapstructure:"provider"`
	ClientMetadata   ClientMetadata     `mapstructure:"client"`
}

type OpenIdProvider interface {
	InitiateIssuance()
	// NewPushedAuthorizationRequest receives the pushed authorization request
	NewPushedAuthorizationRequest(r *http.Request) (AuthorizationRequest, error)
	// NewValidatedAuthorizationRequest receives an open id for credential issuance authorization request and validates it
	NewAuthorizationRequest(r *http.Request) (AuthorizationRequest, error)
	// NewTokenRequest receives an open id token request
	NewTokenRequest(r *http.Request) (TokenRequest, error)
}

type PathNested struct {
	Format string `json:"format"`
	Path   string `json:"path"`
}

type PresentDef map[string]interface{}

type PresentationSubmission struct {
	Id            string          `json:"id"`
	DefinitionId  string          `json:"definition_id"`
	DescriptorMap []DescriptorMap `json:"descriptor_map"`
}

type Proof struct {
	ProofType ProofType `json:"proof_type"`
	Jwt       string    `json:"jwt"`
}

type ProofOfPossession struct {
	ProofType ProofType `json:"proof_type"`
	Jwt       string    `json:"jwt"`
}

type ProofType string

type ProviderMetadata struct {
	// OpenID Connect Discovery 1.0 incorporating errata set 1
	Issuer                     string         `json:"issuer" mapstructure:"issuer"`
	AuthorizationEndpoint      string         `json:"authorization_endpoint" mapstructure:"authorization_endpoint"`
	TokenEndpoint              string         `json:"token_endpoint" mapstructure:"token_endpoint"`
	JwksUri                    string         `json:"jwks_uri" mapstructure:"jwks_uri"`
	ResponseTypesSupported     []ResponseType `json:"response_types_supported" mapstructure:"response_types_supported"`
	SubjectTypesSupported      []SubjectType  `json:"subject_types_supported" mapstructure:"subject_types_supported"`
	IdTokenSigningAlgSupported []string       `json:"id_token_signing_alg_values_supported" mapstructure:"id_token_signing_alg_values_supported"`

	// RFC9126 Pushed Authorization Requests
	PushedEndpoint string `json:"pushed_authorization_request_endpoint" mapstructure:"pushed_authorization_request_endpoint"`
	RequirePushed  bool   `json:"require_pushed_authorization_requests" mapstructure:"require_pushed_authorization_requests"`

	// OpenID for Verifiable Credential Issuance
	CredentialEndpoint   string                   `json:"credential_endpoint" mapstructure:"credential_endpoint"`
	CredentialsSupported []map[string]interface{} `json:"credentials_supported" mapstructure:"credentials_supported"`

	// OpenID for Verifiable Presentations
	PresentationFormats map[string]interface{} `json:"vp_formats_supported" mapstructure:"vp_formats_supported"`
}

type PushedAuthorizationResponse struct {
	RequestUri string        `json:"request_uri"`
	ExpiresIn  time.Duration `json:"expires_in"`
}

type ResponseType string

type ServerConfig struct {
	ExpirationTime time.Duration `mapstructure:"expiration_time"`
}

type SubjectType string

type TokenRequest struct {
	// grant_type is required
	GrantType GrantType `schema:"grant_type,omitempty"`
	// code is required
	Code string `schema:"code,omitempty"`
	// client_id is required
	ClientId string `schema:"client_id,omitempty"`
	// redirect_uri is required
	RedirectUri string `schema:"redirect_uri,omitempty"`
	// code_verifier is required
	CodeVerifier string `schema:"code_verifier,omitempty"`
}

type TokenResponse struct {
	AccessToken     string        `json:"access_token,omitempty"`
	TokenType       string        `json:"token_type,omitempty"`
	ExpiresIn       time.Duration `json:"expires_in,omitempty"`
	CNonce          string        `json:"c_nonce,omitempty"`
	CNonceExpiresIn time.Duration `json:"c_nonce_expires_in,omitempty"`
}

type TokenResponseOption func(*optionalParameters)

type VPTokenOption func(*presentation)