exchange

type ClaimFormat struct {
	JWT   *JWTType `json:"jwt,omitempty" validate:"omitempty,dive"`
	JWTVC *JWTType `json:"jwt_vc,omitempty" validate:"omitempty,dive"`
	JWTVP *JWTType `json:"jwt_vp,omitempty" validate:"omitempty,dive"`

	LDP   *LDPType `json:"ldp,omitempty" validate:"omitempty,dive"`
	LDPVC *LDPType `json:"ldp_vc,omitempty" validate:"omitempty,dive"`
	LDPVP *LDPType `json:"ldp_vp,omitempty" validate:"omitempty,dive"`
}

type Constraints struct {
	Fields          []Field     `json:"fields,omitempty" validate:"omitempty,dive"`
	LimitDisclosure *Preference `json:"limit_disclosure,omitempty"`

	// https://identity.foundation/presentation-exchange/#relational-constraint-feature
	SubjectIsIssuer *Preference            `json:"subject_is_issuer,omitempty"`
	IsHolder        []RelationalConstraint `json:"is_holder,omitempty" validate:"omitempty,dive"`
	SameSubject     []RelationalConstraint `json:"same_subject,omitempty"`

	// https://identity.foundation/presentation-exchange/#credential-status-constraint-feature
	Statuses *CredentialStatus `json:"statuses,omitempty"`
}

type CredentialFormat string

type CredentialStatus struct {
	Active *struct {
		Directive Preference `json:"directive,omitempty"`
	} `json:"active,omitempty"`

	Suspended *struct {
		Directive Preference `json:"directive,omitempty"`
	} `json:"suspended,omitempty"`

	Revoked *struct {
		Directive Preference `json:"directive,omitempty"`
	} `json:"revoked,omitempty"`
}

type EmbedTarget string

type Field struct {
	ID       string   `json:"id,omitempty"`
	Name     string   `json:"name,omitempty"`
	Path     []string `json:"path,omitempty" validate:"required"`
	Purpose  string   `json:"purpose,omitempty"`
	Optional bool     `json:"optional,omitempty"`
	// https://identity.foundation/presentation-exchange/spec/v2.0.0/#retention-feature
	IntentToRetain bool `json:"intent_to_retain,omitempty"`
	// If a predicate property is present, filter must be too
	// https://identity.foundation/presentation-exchange/#predicate-feature
	Predicate *Preference `json:"predicate,omitempty"`
	Filter    *Filter     `json:"filter,omitempty"`
}

type Filter struct {
	Type                 string   `json:"type,omitempty"`
	Format               string   `json:"format,omitempty"`
	Properties           any      `json:"properties,omitempty"`
	Required             []string `json:"required,omitempty"`
	AdditionalProperties bool     `json:"additionalProperties,omitempty"`
	Pattern              string   `json:"pattern,omitempty"`
	Minimum              any      `json:"minimum,omitempty"`
	Maximum              any      `json:"maximum,omitempty"`
	MinLength            int      `json:"minLength,omitempty"`
	MaxLength            int      `json:"maxLength,omitempty"`
	ExclusiveMinimum     any      `json:"exclusiveMinimum,omitempty"`
	ExclusiveMaximum     any      `json:"exclusiveMaximum,omitempty"`
	Const                any      `json:"const,omitempty"`
	Enum                 []any    `json:"enum,omitempty"`
	Not                  any      `json:"not,omitempty"`
	AllOf                any      `json:"allOf,omitempty"`
	OneOf                any      `json:"oneOf,omitempty"`
}

type FromOption struct {
	From       string                  `json:"from,omitempty"`
	FromNested []SubmissionRequirement `json:"from_nested,omitempty"`
}

type InputDescriptor struct {
	// Must be unique within the Presentation Definition
	ID   string `json:"id" validate:"required"`
	Name string `json:"name,omitempty"`
	// Purpose for which claim's data is being requested
	Purpose     string       `json:"purpose,omitempty"`
	Format      *ClaimFormat `json:"format,omitempty" validate:"omitempty,dive"`
	Constraints *Constraints `json:"constraints" validate:"required"`
	// Must match a grouping strings listed in the `from` values of a submission requirement rule
	Group []string `json:"group,omitempty"`
}

type InputDescriptorBuilder struct {
	*InputDescriptor
}

type JWTFormat CredentialFormat

type JWTType struct {
	Alg []crypto.SignatureAlgorithm `json:"alg" validate:"required"`
}

type LDPType struct {
	ProofType []cryptosuite.SignatureType `json:"proof_type" validate:"required"`
}

type LinkedDataFormat CredentialFormat

type NormalizedClaim struct {
	// id for the claim
	ID string
	// json representation of the claim
	Data map[string]any
	// claim in its original format (e.g. Verifiable Credential, token string, etc.)
	RawClaim any
	// JWT_VC, JWT_VP, LDP_VC, LDP_VP, etc.
	Format string
	// Signing algorithm used for the claim (e.g. EdDSA, ES256, PS256, etc.).
	// OR the Linked Data Proof Type (e.g. JsonWebSignature2020)
	AlgOrProofType string
}

type Preference string

type PresentationClaim struct {
	// Data Integrity Claim
	// If we have a Credential or Presentation value, we assume we have a LDP_VC or LDP_VP respectively
	Credential   *credential.VerifiableCredential
	Presentation *credential.VerifiablePresentation
	LDPFormat    *LinkedDataFormat

	// JWT claims
	Token     *string
	JWTFormat *JWTFormat

	// The algorithm or Linked Data proof type by which the claim was signed must be present
	SignatureAlgorithmOrProofType string
}

type PresentationDefinition struct {
	ID                     string                  `json:"id,omitempty" validate:"required"`
	Name                   string                  `json:"name,omitempty"`
	Purpose                string                  `json:"purpose,omitempty"`
	Format                 *ClaimFormat            `json:"format,omitempty" validate:"omitempty,dive"`
	InputDescriptors       []InputDescriptor       `json:"input_descriptors" validate:"required,dive"`
	SubmissionRequirements []SubmissionRequirement `json:"submission_requirements,omitempty" validate:"omitempty,dive"`

	// https://identity.foundation/presentation-exchange/#json-ld-framing-feature
	Frame any `json:"frame,omitempty"`
}

type PresentationDefinitionBuilder struct {
	*PresentationDefinition
}

type PresentationDefinitionEnvelope struct {
	PresentationDefinition `json:"presentation_definition"`
}

type PresentationRequestOption struct {
	Type  PresentationRequestOptionType
	Value any
}

type PresentationRequestOptionType string

type PresentationRequestType string

type PresentationSubmission struct {
	ID            string                 `json:"id" validate:"required"`
	DefinitionID  string                 `json:"definition_id" validate:"required"`
	DescriptorMap []SubmissionDescriptor `json:"descriptor_map" validate:"required"`
}

type PresentationSubmissionBuilder struct {
	*PresentationSubmission
}

type RelationalConstraint struct {
	FieldID   []string    `json:"field_id" validate:"required"`
	Directive *Preference `json:"directive" validate:"required"`
}

type Selection string

type SubmissionDescriptor struct {
	// Must match the `id` property of the corresponding input descriptor
	ID         string                `json:"id" validate:"required"`
	Format     string                `json:"format" validate:"required"`
	Path       string                `json:"path" validate:"required"`
	PathNested *SubmissionDescriptor `json:"path_nested,omitempty"`
}

type SubmissionRequirement struct {
	Rule Selection `json:"rule" validate:"required"`
	// Either an array of SubmissionRequirement OR a string value
	FromOption `validate:"required"`

	Name    string `json:"name,omitempty"`
	Purpose string `json:"purpose,omitempty"`
	Count   int    `json:"count,omitempty" validate:"omitempty,min=1"`
	Minimum int    `json:"min,omitempty"`
	Maximum int    `json:"max,omitempty"`
}

type VerifiedSubmissionData struct {
	// The ID of the input descriptor that was verified
	InputDescriptorID string
	// The raw claim data that was verified – could be a JWT, or a VC, or a VP
	Claim any
	// The filtered data as a JSON string
	FilteredData any
}