models

package
v0.0.0-...-d1463b1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 25, 2025 License: Apache-2.0 Imports: 11 Imported by: 0

Documentation

Index

Constants

View Source 
const (

	// HashedrekordV001SchemaDataHashAlgorithmSha256 captures enum value "sha256"
	HashedrekordV001SchemaDataHashAlgorithmSha256 string = "sha256"

	// HashedrekordV001SchemaDataHashAlgorithmSha384 captures enum value "sha384"
	HashedrekordV001SchemaDataHashAlgorithmSha384 string = "sha384"

	// HashedrekordV001SchemaDataHashAlgorithmSha512 captures enum value "sha512"
	HashedrekordV001SchemaDataHashAlgorithmSha512 string = "sha512"
)
View Source 
const (

	// PkgTypesHashedrekordV001HashedrekordV001SchemaDataHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesHashedrekordV001HashedrekordV001SchemaDataHashAlgorithmSha256 string = "sha256"

	// PkgTypesHashedrekordV001HashedrekordV001SchemaDataHashAlgorithmSha384 captures enum value "sha384"
	PkgTypesHashedrekordV001HashedrekordV001SchemaDataHashAlgorithmSha384 string = "sha384"

	// PkgTypesHashedrekordV001HashedrekordV001SchemaDataHashAlgorithmSha512 captures enum value "sha512"
	PkgTypesHashedrekordV001HashedrekordV001SchemaDataHashAlgorithmSha512 string = "sha512"
)
View Source 
const (

	// PkgTypesRekordV001RekordV001SchemaSignatureFormatPgp captures enum value "pgp"
	PkgTypesRekordV001RekordV001SchemaSignatureFormatPgp string = "pgp"

	// PkgTypesRekordV001RekordV001SchemaSignatureFormatMinisign captures enum value "minisign"
	PkgTypesRekordV001RekordV001SchemaSignatureFormatMinisign string = "minisign"

	// PkgTypesRekordV001RekordV001SchemaSignatureFormatX509 captures enum value "x509"
	PkgTypesRekordV001RekordV001SchemaSignatureFormatX509 string = "x509"

	// PkgTypesRekordV001RekordV001SchemaSignatureFormatSSH captures enum value "ssh"
	PkgTypesRekordV001RekordV001SchemaSignatureFormatSSH string = "ssh"
)
View Source 
const (

	// RekordV001SchemaSignatureFormatPgp captures enum value "pgp"
	RekordV001SchemaSignatureFormatPgp string = "pgp"

	// RekordV001SchemaSignatureFormatMinisign captures enum value "minisign"
	RekordV001SchemaSignatureFormatMinisign string = "minisign"

	// RekordV001SchemaSignatureFormatX509 captures enum value "x509"
	RekordV001SchemaSignatureFormatX509 string = "x509"

	// RekordV001SchemaSignatureFormatSSH captures enum value "ssh"
	RekordV001SchemaSignatureFormatSSH string = "ssh"
)
View Source 
const (

	// SearchIndexOperatorAnd captures enum value "and"
	SearchIndexOperatorAnd string = "and"

	// SearchIndexOperatorOr captures enum value "or"
	SearchIndexOperatorOr string = "or"
)
View Source 
const (

	// SearchIndexPublicKeyFormatPgp captures enum value "pgp"
	SearchIndexPublicKeyFormatPgp string = "pgp"

	// SearchIndexPublicKeyFormatX509 captures enum value "x509"
	SearchIndexPublicKeyFormatX509 string = "x509"

	// SearchIndexPublicKeyFormatMinisign captures enum value "minisign"
	SearchIndexPublicKeyFormatMinisign string = "minisign"

	// SearchIndexPublicKeyFormatSSH captures enum value "ssh"
	SearchIndexPublicKeyFormatSSH string = "ssh"

	// SearchIndexPublicKeyFormatTuf captures enum value "tuf"
	SearchIndexPublicKeyFormatTuf string = "tuf"
)
View Source 
const (

	// AlpineV001SchemaPackageHashAlgorithmSha256 captures enum value "sha256"
	AlpineV001SchemaPackageHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// CoseV001SchemaDataEnvelopeHashAlgorithmSha256 captures enum value "sha256"
	CoseV001SchemaDataEnvelopeHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// CoseV001SchemaDataPayloadHashAlgorithmSha256 captures enum value "sha256"
	CoseV001SchemaDataPayloadHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// HelmV001SchemaChartHashAlgorithmSha256 captures enum value "sha256"
	HelmV001SchemaChartHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// IntotoV001SchemaContentHashAlgorithmSha256 captures enum value "sha256"
	IntotoV001SchemaContentHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// IntotoV001SchemaContentPayloadHashAlgorithmSha256 captures enum value "sha256"
	IntotoV001SchemaContentPayloadHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// IntotoV002SchemaContentHashAlgorithmSha256 captures enum value "sha256"
	IntotoV002SchemaContentHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// IntotoV002SchemaContentPayloadHashAlgorithmSha256 captures enum value "sha256"
	IntotoV002SchemaContentPayloadHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// JarV001SchemaArchiveHashAlgorithmSha256 captures enum value "sha256"
	JarV001SchemaArchiveHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesAlpineV001AlpineV001SchemaPackageHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesAlpineV001AlpineV001SchemaPackageHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesCoseV001CoseV001SchemaDataEnvelopeHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesCoseV001CoseV001SchemaDataEnvelopeHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesCoseV001CoseV001SchemaDataPayloadHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesCoseV001CoseV001SchemaDataPayloadHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesDsseV001DsseV001SchemaEnvelopeHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesDsseV001DsseV001SchemaEnvelopeHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesDsseV001DsseV001SchemaPayloadHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesDsseV001DsseV001SchemaPayloadHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesHelmV001HelmV001SchemaChartHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesHelmV001HelmV001SchemaChartHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesIntotoV001IntotoV001SchemaContentHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesIntotoV001IntotoV001SchemaContentHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesIntotoV001IntotoV001SchemaContentPayloadHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesIntotoV001IntotoV001SchemaContentPayloadHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesIntotoV002IntotoV002SchemaContentHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesIntotoV002IntotoV002SchemaContentHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesIntotoV002IntotoV002SchemaContentPayloadHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesIntotoV002IntotoV002SchemaContentPayloadHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesJarV001JarV001SchemaArchiveHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesJarV001JarV001SchemaArchiveHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesRekordV001RekordV001SchemaDataHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesRekordV001RekordV001SchemaDataHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// PkgTypesRpmV001RpmV001SchemaPackageHashAlgorithmSha256 captures enum value "sha256"
	PkgTypesRpmV001RpmV001SchemaPackageHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// RekordV001SchemaDataHashAlgorithmSha256 captures enum value "sha256"
	RekordV001SchemaDataHashAlgorithmSha256 string = "sha256"
)
View Source 
const (

	// RpmV001SchemaPackageHashAlgorithmSha256 captures enum value "sha256"
	RpmV001SchemaPackageHashAlgorithmSha256 string = "sha256"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Alpine 

type Alpine struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec AlpineSchema `json:"spec"`
}

Alpine Alpine package

swagger:model alpine

func (*Alpine) ContextValidate 

func (m *Alpine) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this alpine based on the context it is used

func (*Alpine) Kind 

func (m *Alpine) Kind() string

Kind gets the kind of this subtype

func (*Alpine) MarshalBinary 

func (m *Alpine) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Alpine) MarshalJSON 

func (m Alpine) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Alpine) SetKind 

func (m *Alpine) SetKind(val string)

SetKind sets the kind of this subtype

func (*Alpine) UnmarshalBinary 

func (m *Alpine) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Alpine) UnmarshalJSON 

func (m *Alpine) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Alpine) Validate 

func (m *Alpine) Validate(formats strfmt.Registry) error

Validate validates this alpine

type AlpineSchema 

type AlpineSchema interface{}

AlpineSchema Alpine Package Schema

Schema for Alpine package objects

swagger:model alpineSchema

type AlpineV001Schema 

type AlpineV001Schema struct {

	// package
	// Required: true
	Package *AlpineV001SchemaPackage `json:"package"`

	// public key
	// Required: true
	PublicKey *AlpineV001SchemaPublicKey `json:"publicKey"`
}

AlpineV001Schema Alpine v0.0.1 Schema

Schema for Alpine Package entries

swagger:model alpineV001Schema

func (*AlpineV001Schema) ContextValidate 

func (m *AlpineV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this alpine v001 schema based on the context it is used

func (*AlpineV001Schema) MarshalBinary 

func (m *AlpineV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AlpineV001Schema) UnmarshalBinary 

func (m *AlpineV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AlpineV001Schema) Validate 

func (m *AlpineV001Schema) Validate(formats strfmt.Registry) error

Validate validates this alpine v001 schema

type AlpineV001SchemaPackage 

type AlpineV001SchemaPackage struct {

	// Specifies the package inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *AlpineV001SchemaPackageHash `json:"hash,omitempty"`

	// Values of the .PKGINFO key / value pairs
	// Read Only: true
	Pkginfo map[string]string `json:"pkginfo,omitempty"`
}

AlpineV001SchemaPackage Information about the package associated with the entry

swagger:model AlpineV001SchemaPackage

func (*AlpineV001SchemaPackage) ContextValidate 

func (m *AlpineV001SchemaPackage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this alpine v001 schema package based on the context it is used

func (*AlpineV001SchemaPackage) MarshalBinary 

func (m *AlpineV001SchemaPackage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AlpineV001SchemaPackage) UnmarshalBinary 

func (m *AlpineV001SchemaPackage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AlpineV001SchemaPackage) Validate 

func (m *AlpineV001SchemaPackage) Validate(formats strfmt.Registry) error

Validate validates this alpine v001 schema package

type AlpineV001SchemaPackageHash 

type AlpineV001SchemaPackageHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the package
	// Required: true
	Value *string `json:"value"`
}

AlpineV001SchemaPackageHash Specifies the hash algorithm and value for the package

swagger:model AlpineV001SchemaPackageHash

func (*AlpineV001SchemaPackageHash) ContextValidate 

func (m *AlpineV001SchemaPackageHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this alpine v001 schema package hash based on the context it is used

func (*AlpineV001SchemaPackageHash) MarshalBinary 

func (m *AlpineV001SchemaPackageHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AlpineV001SchemaPackageHash) UnmarshalBinary 

func (m *AlpineV001SchemaPackageHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AlpineV001SchemaPackageHash) Validate 

func (m *AlpineV001SchemaPackageHash) Validate(formats strfmt.Registry) error

Validate validates this alpine v001 schema package hash

type AlpineV001SchemaPublicKey 

type AlpineV001SchemaPublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

AlpineV001SchemaPublicKey The public key that can verify the package signature

swagger:model AlpineV001SchemaPublicKey

func (*AlpineV001SchemaPublicKey) ContextValidate 

func (m *AlpineV001SchemaPublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this alpine v001 schema public key based on context it is used

func (*AlpineV001SchemaPublicKey) MarshalBinary 

func (m *AlpineV001SchemaPublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AlpineV001SchemaPublicKey) UnmarshalBinary 

func (m *AlpineV001SchemaPublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AlpineV001SchemaPublicKey) Validate 

func (m *AlpineV001SchemaPublicKey) Validate(formats strfmt.Registry) error

Validate validates this alpine v001 schema public key

type ConsistencyProof 

type ConsistencyProof struct {

	// hashes
	// Required: true
	Hashes []string `json:"hashes"`

	// The hash value stored at the root of the merkle tree at the time the proof was generated
	// Required: true
	// Pattern: ^[0-9a-fA-F]{64}$
	RootHash *string `json:"rootHash"`
}

ConsistencyProof consistency proof

swagger:model ConsistencyProof

func (*ConsistencyProof) ContextValidate 

func (m *ConsistencyProof) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this consistency proof based on context it is used

func (*ConsistencyProof) MarshalBinary 

func (m *ConsistencyProof) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsistencyProof) UnmarshalBinary 

func (m *ConsistencyProof) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsistencyProof) Validate 

func (m *ConsistencyProof) Validate(formats strfmt.Registry) error

Validate validates this consistency proof

type Cose 

type Cose struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec CoseSchema `json:"spec"`
}

Cose COSE object

swagger:model cose

func (*Cose) ContextValidate 

func (m *Cose) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cose based on the context it is used

func (*Cose) Kind 

func (m *Cose) Kind() string

Kind gets the kind of this subtype

func (*Cose) MarshalBinary 

func (m *Cose) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Cose) MarshalJSON 

func (m Cose) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Cose) SetKind 

func (m *Cose) SetKind(val string)

SetKind sets the kind of this subtype

func (*Cose) UnmarshalBinary 

func (m *Cose) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Cose) UnmarshalJSON 

func (m *Cose) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Cose) Validate 

func (m *Cose) Validate(formats strfmt.Registry) error

Validate validates this cose

type CoseSchema 

type CoseSchema interface{}

CoseSchema COSE Schema

COSE for Rekord objects

swagger:model coseSchema

type CoseV001Schema 

type CoseV001Schema struct {

	// data
	Data *CoseV001SchemaData `json:"data,omitempty"`

	// The COSE Sign1 Message
	// Format: byte
	Message strfmt.Base64 `json:"message,omitempty"`

	// The public key that can verify the signature
	// Required: true
	// Format: byte
	PublicKey *strfmt.Base64 `json:"publicKey"`
}

CoseV001Schema cose v0.0.1 Schema

Schema for cose object

swagger:model coseV001Schema

func (*CoseV001Schema) ContextValidate 

func (m *CoseV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cose v001 schema based on the context it is used

func (*CoseV001Schema) MarshalBinary 

func (m *CoseV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CoseV001Schema) UnmarshalBinary 

func (m *CoseV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CoseV001Schema) Validate 

func (m *CoseV001Schema) Validate(formats strfmt.Registry) error

Validate validates this cose v001 schema

type CoseV001SchemaData 

type CoseV001SchemaData struct {

	// Specifies the additional authenticated data required to verify the signature
	// Format: byte
	Aad strfmt.Base64 `json:"aad,omitempty"`

	// envelope hash
	EnvelopeHash *CoseV001SchemaDataEnvelopeHash `json:"envelopeHash,omitempty"`

	// payload hash
	PayloadHash *CoseV001SchemaDataPayloadHash `json:"payloadHash,omitempty"`
}

CoseV001SchemaData Information about the content associated with the entry

swagger:model CoseV001SchemaData

func (*CoseV001SchemaData) ContextValidate 

func (m *CoseV001SchemaData) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cose v001 schema data based on the context it is used

func (*CoseV001SchemaData) MarshalBinary 

func (m *CoseV001SchemaData) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CoseV001SchemaData) UnmarshalBinary 

func (m *CoseV001SchemaData) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CoseV001SchemaData) Validate 

func (m *CoseV001SchemaData) Validate(formats strfmt.Registry) error

Validate validates this cose v001 schema data

type CoseV001SchemaDataEnvelopeHash 

type CoseV001SchemaDataEnvelopeHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the envelope
	// Required: true
	Value *string `json:"value"`
}

CoseV001SchemaDataEnvelopeHash Specifies the hash algorithm and value for the COSE envelope

swagger:model CoseV001SchemaDataEnvelopeHash

func (*CoseV001SchemaDataEnvelopeHash) ContextValidate 

func (m *CoseV001SchemaDataEnvelopeHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cose v001 schema data envelope hash based on the context it is used

func (*CoseV001SchemaDataEnvelopeHash) MarshalBinary 

func (m *CoseV001SchemaDataEnvelopeHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CoseV001SchemaDataEnvelopeHash) UnmarshalBinary 

func (m *CoseV001SchemaDataEnvelopeHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CoseV001SchemaDataEnvelopeHash) Validate 

func (m *CoseV001SchemaDataEnvelopeHash) Validate(formats strfmt.Registry) error

Validate validates this cose v001 schema data envelope hash

type CoseV001SchemaDataPayloadHash 

type CoseV001SchemaDataPayloadHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the content
	// Required: true
	Value *string `json:"value"`
}

CoseV001SchemaDataPayloadHash Specifies the hash algorithm and value for the content

swagger:model CoseV001SchemaDataPayloadHash

func (*CoseV001SchemaDataPayloadHash) ContextValidate 

func (m *CoseV001SchemaDataPayloadHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this cose v001 schema data payload hash based on the context it is used

func (*CoseV001SchemaDataPayloadHash) MarshalBinary 

func (m *CoseV001SchemaDataPayloadHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CoseV001SchemaDataPayloadHash) UnmarshalBinary 

func (m *CoseV001SchemaDataPayloadHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CoseV001SchemaDataPayloadHash) Validate 

func (m *CoseV001SchemaDataPayloadHash) Validate(formats strfmt.Registry) error

Validate validates this cose v001 schema data payload hash

type Error 

type Error struct {

	// code
	Code int64 `json:"code,omitempty"`

	// message
	Message string `json:"message,omitempty"`
}

Error error

swagger:model Error

func (*Error) ContextValidate 

func (m *Error) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this error based on context it is used

func (*Error) MarshalBinary 

func (m *Error) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Error) UnmarshalBinary 

func (m *Error) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Error) Validate 

func (m *Error) Validate(formats strfmt.Registry) error

Validate validates this error

type Hashedrekord 

type Hashedrekord struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec HashedrekordSchema `json:"spec"`
}

Hashedrekord Hashed Rekord object

swagger:model hashedrekord

func (*Hashedrekord) ContextValidate 

func (m *Hashedrekord) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashedrekord based on the context it is used

func (*Hashedrekord) Kind 

func (m *Hashedrekord) Kind() string

Kind gets the kind of this subtype

func (*Hashedrekord) MarshalBinary 

func (m *Hashedrekord) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Hashedrekord) MarshalJSON 

func (m Hashedrekord) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Hashedrekord) SetKind 

func (m *Hashedrekord) SetKind(val string)

SetKind sets the kind of this subtype

func (*Hashedrekord) UnmarshalBinary 

func (m *Hashedrekord) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Hashedrekord) UnmarshalJSON 

func (m *Hashedrekord) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Hashedrekord) Validate 

func (m *Hashedrekord) Validate(formats strfmt.Registry) error

Validate validates this hashedrekord

type HashedrekordSchema 

type HashedrekordSchema interface{}

HashedrekordSchema Hashedrekord Schema

Schema for Hashedrekord objects

swagger:model hashedrekordSchema

type HashedrekordV001Schema 

type HashedrekordV001Schema struct {

	// data
	// Required: true
	Data *HashedrekordV001SchemaData `json:"data"`

	// signature
	// Required: true
	Signature *HashedrekordV001SchemaSignature `json:"signature"`
}

HashedrekordV001Schema Hashed Rekor v0.0.1 Schema

Schema for Hashed Rekord object

swagger:model hashedrekordV001Schema

func (*HashedrekordV001Schema) ContextValidate 

func (m *HashedrekordV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashedrekord v001 schema based on the context it is used

func (*HashedrekordV001Schema) MarshalBinary 

func (m *HashedrekordV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashedrekordV001Schema) UnmarshalBinary 

func (m *HashedrekordV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashedrekordV001Schema) Validate 

func (m *HashedrekordV001Schema) Validate(formats strfmt.Registry) error

Validate validates this hashedrekord v001 schema

type HashedrekordV001SchemaData 

type HashedrekordV001SchemaData struct {

	// hash
	Hash *HashedrekordV001SchemaDataHash `json:"hash,omitempty"`
}

HashedrekordV001SchemaData Information about the content associated with the entry

swagger:model HashedrekordV001SchemaData

func (*HashedrekordV001SchemaData) ContextValidate 

func (m *HashedrekordV001SchemaData) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashedrekord v001 schema data based on the context it is used

func (*HashedrekordV001SchemaData) MarshalBinary 

func (m *HashedrekordV001SchemaData) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashedrekordV001SchemaData) UnmarshalBinary 

func (m *HashedrekordV001SchemaData) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashedrekordV001SchemaData) Validate 

func (m *HashedrekordV001SchemaData) Validate(formats strfmt.Registry) error

Validate validates this hashedrekord v001 schema data

type HashedrekordV001SchemaDataHash 

type HashedrekordV001SchemaDataHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256","sha384","sha512"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the content, as represented by a lower case hexadecimal string
	// Required: true
	Value *string `json:"value"`
}

HashedrekordV001SchemaDataHash Specifies the hash algorithm and value for the content

swagger:model HashedrekordV001SchemaDataHash

func (*HashedrekordV001SchemaDataHash) ContextValidate 

func (m *HashedrekordV001SchemaDataHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashedrekord v001 schema data hash based on context it is used

func (*HashedrekordV001SchemaDataHash) MarshalBinary 

func (m *HashedrekordV001SchemaDataHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashedrekordV001SchemaDataHash) UnmarshalBinary 

func (m *HashedrekordV001SchemaDataHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashedrekordV001SchemaDataHash) Validate 

func (m *HashedrekordV001SchemaDataHash) Validate(formats strfmt.Registry) error

Validate validates this hashedrekord v001 schema data hash

type HashedrekordV001SchemaSignature 

type HashedrekordV001SchemaSignature struct {

	// Specifies the content of the signature inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// public key
	PublicKey *HashedrekordV001SchemaSignaturePublicKey `json:"publicKey,omitempty"`
}

HashedrekordV001SchemaSignature Information about the detached signature associated with the entry

swagger:model HashedrekordV001SchemaSignature

func (*HashedrekordV001SchemaSignature) ContextValidate 

func (m *HashedrekordV001SchemaSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this hashedrekord v001 schema signature based on the context it is used

func (*HashedrekordV001SchemaSignature) MarshalBinary 

func (m *HashedrekordV001SchemaSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashedrekordV001SchemaSignature) UnmarshalBinary 

func (m *HashedrekordV001SchemaSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashedrekordV001SchemaSignature) Validate 

func (m *HashedrekordV001SchemaSignature) Validate(formats strfmt.Registry) error

Validate validates this hashedrekord v001 schema signature

type HashedrekordV001SchemaSignaturePublicKey 

type HashedrekordV001SchemaSignaturePublicKey struct {

	// Specifies the content of the public key or code signing certificate inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`
}

HashedrekordV001SchemaSignaturePublicKey The public key that can verify the signature; this can also be an X509 code signing certificate that contains the raw public key information

swagger:model HashedrekordV001SchemaSignaturePublicKey

func (*HashedrekordV001SchemaSignaturePublicKey) ContextValidate 

func (m *HashedrekordV001SchemaSignaturePublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this hashedrekord v001 schema signature public key based on context it is used

func (*HashedrekordV001SchemaSignaturePublicKey) MarshalBinary 

func (m *HashedrekordV001SchemaSignaturePublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HashedrekordV001SchemaSignaturePublicKey) UnmarshalBinary 

func (m *HashedrekordV001SchemaSignaturePublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HashedrekordV001SchemaSignaturePublicKey) Validate 

func (m *HashedrekordV001SchemaSignaturePublicKey) Validate(formats strfmt.Registry) error

Validate validates this hashedrekord v001 schema signature public key

type Helm 

type Helm struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec HelmSchema `json:"spec"`
}

Helm Helm chart

swagger:model helm

func (*Helm) ContextValidate 

func (m *Helm) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this helm based on the context it is used

func (*Helm) Kind 

func (m *Helm) Kind() string

Kind gets the kind of this subtype

func (*Helm) MarshalBinary 

func (m *Helm) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Helm) MarshalJSON 

func (m Helm) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Helm) SetKind 

func (m *Helm) SetKind(val string)

SetKind sets the kind of this subtype

func (*Helm) UnmarshalBinary 

func (m *Helm) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Helm) UnmarshalJSON 

func (m *Helm) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Helm) Validate 

func (m *Helm) Validate(formats strfmt.Registry) error

Validate validates this helm

type HelmSchema 

type HelmSchema interface{}

HelmSchema Helm Schema

Schema for Helm objects

swagger:model helmSchema

type HelmV001Schema 

type HelmV001Schema struct {

	// chart
	// Required: true
	Chart *HelmV001SchemaChart `json:"chart"`

	// public key
	// Required: true
	PublicKey *HelmV001SchemaPublicKey `json:"publicKey"`
}

HelmV001Schema Helm v0.0.1 Schema

Schema for Helm object

swagger:model helmV001Schema

func (*HelmV001Schema) ContextValidate 

func (m *HelmV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this helm v001 schema based on the context it is used

func (*HelmV001Schema) MarshalBinary 

func (m *HelmV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HelmV001Schema) UnmarshalBinary 

func (m *HelmV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HelmV001Schema) Validate 

func (m *HelmV001Schema) Validate(formats strfmt.Registry) error

Validate validates this helm v001 schema

type HelmV001SchemaChart 

type HelmV001SchemaChart struct {

	// hash
	Hash *HelmV001SchemaChartHash `json:"hash,omitempty"`

	// provenance
	// Required: true
	Provenance *HelmV001SchemaChartProvenance `json:"provenance"`
}

HelmV001SchemaChart Information about the Helm chart associated with the entry

swagger:model HelmV001SchemaChart

func (*HelmV001SchemaChart) ContextValidate 

func (m *HelmV001SchemaChart) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this helm v001 schema chart based on the context it is used

func (*HelmV001SchemaChart) MarshalBinary 

func (m *HelmV001SchemaChart) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HelmV001SchemaChart) UnmarshalBinary 

func (m *HelmV001SchemaChart) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HelmV001SchemaChart) Validate 

func (m *HelmV001SchemaChart) Validate(formats strfmt.Registry) error

Validate validates this helm v001 schema chart

type HelmV001SchemaChartHash 

type HelmV001SchemaChartHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the chart
	// Required: true
	Value *string `json:"value"`
}

HelmV001SchemaChartHash Specifies the hash algorithm and value for the chart

swagger:model HelmV001SchemaChartHash

func (*HelmV001SchemaChartHash) ContextValidate 

func (m *HelmV001SchemaChartHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this helm v001 schema chart hash based on the context it is used

func (*HelmV001SchemaChartHash) MarshalBinary 

func (m *HelmV001SchemaChartHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HelmV001SchemaChartHash) UnmarshalBinary 

func (m *HelmV001SchemaChartHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HelmV001SchemaChartHash) Validate 

func (m *HelmV001SchemaChartHash) Validate(formats strfmt.Registry) error

Validate validates this helm v001 schema chart hash

type HelmV001SchemaChartProvenance 

type HelmV001SchemaChartProvenance struct {

	// Specifies the content of the provenance file inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// signature
	Signature *HelmV001SchemaChartProvenanceSignature `json:"signature,omitempty"`
}

HelmV001SchemaChartProvenance The provenance entry associated with the signed Helm Chart

swagger:model HelmV001SchemaChartProvenance

func (*HelmV001SchemaChartProvenance) ContextValidate 

func (m *HelmV001SchemaChartProvenance) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this helm v001 schema chart provenance based on the context it is used

func (*HelmV001SchemaChartProvenance) MarshalBinary 

func (m *HelmV001SchemaChartProvenance) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HelmV001SchemaChartProvenance) UnmarshalBinary 

func (m *HelmV001SchemaChartProvenance) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HelmV001SchemaChartProvenance) Validate 

func (m *HelmV001SchemaChartProvenance) Validate(formats strfmt.Registry) error

Validate validates this helm v001 schema chart provenance

type HelmV001SchemaChartProvenanceSignature 

type HelmV001SchemaChartProvenanceSignature struct {

	// Specifies the signature embedded within the provenance file
	// Required: true
	// Read Only: true
	// Format: byte
	Content strfmt.Base64 `json:"content"`
}

HelmV001SchemaChartProvenanceSignature Information about the included signature in the provenance file

swagger:model HelmV001SchemaChartProvenanceSignature

func (*HelmV001SchemaChartProvenanceSignature) ContextValidate 

func (m *HelmV001SchemaChartProvenanceSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this helm v001 schema chart provenance signature based on the context it is used

func (*HelmV001SchemaChartProvenanceSignature) MarshalBinary 

func (m *HelmV001SchemaChartProvenanceSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HelmV001SchemaChartProvenanceSignature) UnmarshalBinary 

func (m *HelmV001SchemaChartProvenanceSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HelmV001SchemaChartProvenanceSignature) Validate 

func (m *HelmV001SchemaChartProvenanceSignature) Validate(formats strfmt.Registry) error

Validate validates this helm v001 schema chart provenance signature

type HelmV001SchemaPublicKey 

type HelmV001SchemaPublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

HelmV001SchemaPublicKey The public key that can verify the package signature

swagger:model HelmV001SchemaPublicKey

func (*HelmV001SchemaPublicKey) ContextValidate 

func (m *HelmV001SchemaPublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this helm v001 schema public key based on context it is used

func (*HelmV001SchemaPublicKey) MarshalBinary 

func (m *HelmV001SchemaPublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*HelmV001SchemaPublicKey) UnmarshalBinary 

func (m *HelmV001SchemaPublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*HelmV001SchemaPublicKey) Validate 

func (m *HelmV001SchemaPublicKey) Validate(formats strfmt.Registry) error

Validate validates this helm v001 schema public key

type InactiveShardLogInfo 

type InactiveShardLogInfo struct {

	// The current hash value stored at the root of the merkle tree
	// Required: true
	// Pattern: ^[0-9a-fA-F]{64}$
	RootHash *string `json:"rootHash"`

	// The current signed tree head
	// Required: true
	SignedTreeHead *string `json:"signedTreeHead"`

	// The current treeID
	// Required: true
	// Pattern: ^[0-9]+$
	TreeID *string `json:"treeID"`

	// The current number of nodes in the merkle tree
	// Required: true
	// Minimum: 1
	TreeSize *int64 `json:"treeSize"`
}

InactiveShardLogInfo inactive shard log info

swagger:model InactiveShardLogInfo

func (*InactiveShardLogInfo) ContextValidate 

func (m *InactiveShardLogInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this inactive shard log info based on context it is used

func (*InactiveShardLogInfo) MarshalBinary 

func (m *InactiveShardLogInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InactiveShardLogInfo) UnmarshalBinary 

func (m *InactiveShardLogInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InactiveShardLogInfo) Validate 

func (m *InactiveShardLogInfo) Validate(formats strfmt.Registry) error

Validate validates this inactive shard log info

type InclusionProof 

type InclusionProof struct {

	// The checkpoint (signed tree head) that the inclusion proof is based on
	// Required: true
	Checkpoint *string `json:"checkpoint"`

	// A list of hashes required to compute the inclusion proof, sorted in order from leaf to root
	// Required: true
	Hashes []string `json:"hashes"`

	// The index of the entry in the transparency log
	// Required: true
	// Minimum: 0
	LogIndex *int64 `json:"logIndex"`

	// The hash value stored at the root of the merkle tree at the time the proof was generated
	// Required: true
	// Pattern: ^[0-9a-fA-F]{64}$
	RootHash *string `json:"rootHash"`

	// The size of the merkle tree at the time the inclusion proof was generated
	// Required: true
	// Minimum: 1
	TreeSize *int64 `json:"treeSize"`
}

InclusionProof inclusion proof

swagger:model InclusionProof

func (*InclusionProof) ContextValidate 

func (m *InclusionProof) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this inclusion proof based on context it is used

func (*InclusionProof) MarshalBinary 

func (m *InclusionProof) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InclusionProof) UnmarshalBinary 

func (m *InclusionProof) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InclusionProof) Validate 

func (m *InclusionProof) Validate(formats strfmt.Registry) error

Validate validates this inclusion proof

type Intoto 

type Intoto struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec IntotoSchema `json:"spec"`
}

Intoto Intoto object

swagger:model intoto

func (*Intoto) ContextValidate 

func (m *Intoto) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto based on the context it is used

func (*Intoto) Kind 

func (m *Intoto) Kind() string

Kind gets the kind of this subtype

func (*Intoto) MarshalBinary 

func (m *Intoto) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Intoto) MarshalJSON 

func (m Intoto) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Intoto) SetKind 

func (m *Intoto) SetKind(val string)

SetKind sets the kind of this subtype

func (*Intoto) UnmarshalBinary 

func (m *Intoto) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Intoto) UnmarshalJSON 

func (m *Intoto) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Intoto) Validate 

func (m *Intoto) Validate(formats strfmt.Registry) error

Validate validates this intoto

type IntotoSchema 

type IntotoSchema interface{}

IntotoSchema Intoto Schema

Intoto for Rekord objects

swagger:model intotoSchema

type IntotoV001Schema 

type IntotoV001Schema struct {

	// content
	// Required: true
	Content *IntotoV001SchemaContent `json:"content"`

	// The public key that can verify the signature
	// Required: true
	// Format: byte
	PublicKey *strfmt.Base64 `json:"publicKey"`
}

IntotoV001Schema intoto v0.0.1 Schema

Schema for intoto object

swagger:model intotoV001Schema

func (*IntotoV001Schema) ContextValidate 

func (m *IntotoV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v001 schema based on the context it is used

func (*IntotoV001Schema) MarshalBinary 

func (m *IntotoV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV001Schema) UnmarshalBinary 

func (m *IntotoV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV001Schema) Validate 

func (m *IntotoV001Schema) Validate(formats strfmt.Registry) error

Validate validates this intoto v001 schema

type IntotoV001SchemaContent 

type IntotoV001SchemaContent struct {

	// envelope
	Envelope string `json:"envelope,omitempty"`

	// hash
	Hash *IntotoV001SchemaContentHash `json:"hash,omitempty"`

	// payload hash
	PayloadHash *IntotoV001SchemaContentPayloadHash `json:"payloadHash,omitempty"`
}

IntotoV001SchemaContent intoto v001 schema content

swagger:model IntotoV001SchemaContent

func (*IntotoV001SchemaContent) ContextValidate 

func (m *IntotoV001SchemaContent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v001 schema content based on the context it is used

func (*IntotoV001SchemaContent) MarshalBinary 

func (m *IntotoV001SchemaContent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV001SchemaContent) UnmarshalBinary 

func (m *IntotoV001SchemaContent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV001SchemaContent) Validate 

func (m *IntotoV001SchemaContent) Validate(formats strfmt.Registry) error

Validate validates this intoto v001 schema content

type IntotoV001SchemaContentHash 

type IntotoV001SchemaContentHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the archive
	// Required: true
	Value *string `json:"value"`
}

IntotoV001SchemaContentHash Specifies the hash algorithm and value encompassing the entire signed envelope; this is computed by the rekor server, client-provided values are ignored

swagger:model IntotoV001SchemaContentHash

func (*IntotoV001SchemaContentHash) ContextValidate 

func (m *IntotoV001SchemaContentHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v001 schema content hash based on the context it is used

func (*IntotoV001SchemaContentHash) MarshalBinary 

func (m *IntotoV001SchemaContentHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV001SchemaContentHash) UnmarshalBinary 

func (m *IntotoV001SchemaContentHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV001SchemaContentHash) Validate 

func (m *IntotoV001SchemaContentHash) Validate(formats strfmt.Registry) error

Validate validates this intoto v001 schema content hash

type IntotoV001SchemaContentPayloadHash 

type IntotoV001SchemaContentPayloadHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the envelope's payload
	// Required: true
	Value *string `json:"value"`
}

IntotoV001SchemaContentPayloadHash Specifies the hash algorithm and value covering the payload within the DSSE envelope; this is computed by the rekor server, client-provided values are ignored

swagger:model IntotoV001SchemaContentPayloadHash

func (*IntotoV001SchemaContentPayloadHash) ContextValidate 

func (m *IntotoV001SchemaContentPayloadHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v001 schema content payload hash based on the context it is used

func (*IntotoV001SchemaContentPayloadHash) MarshalBinary 

func (m *IntotoV001SchemaContentPayloadHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV001SchemaContentPayloadHash) UnmarshalBinary 

func (m *IntotoV001SchemaContentPayloadHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV001SchemaContentPayloadHash) Validate 

func (m *IntotoV001SchemaContentPayloadHash) Validate(formats strfmt.Registry) error

Validate validates this intoto v001 schema content payload hash

type IntotoV002Schema 

type IntotoV002Schema struct {

	// content
	// Required: true
	Content *IntotoV002SchemaContent `json:"content"`
}

IntotoV002Schema intoto v0.0.2 Schema

Schema for intoto object

swagger:model intotoV002Schema

func (*IntotoV002Schema) ContextValidate 

func (m *IntotoV002Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v002 schema based on the context it is used

func (*IntotoV002Schema) MarshalBinary 

func (m *IntotoV002Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV002Schema) UnmarshalBinary 

func (m *IntotoV002Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV002Schema) Validate 

func (m *IntotoV002Schema) Validate(formats strfmt.Registry) error

Validate validates this intoto v002 schema

type IntotoV002SchemaContent 

type IntotoV002SchemaContent struct {

	// envelope
	// Required: true
	Envelope *IntotoV002SchemaContentEnvelope `json:"envelope"`

	// hash
	Hash *IntotoV002SchemaContentHash `json:"hash,omitempty"`

	// payload hash
	PayloadHash *IntotoV002SchemaContentPayloadHash `json:"payloadHash,omitempty"`
}

IntotoV002SchemaContent intoto v002 schema content

swagger:model IntotoV002SchemaContent

func (*IntotoV002SchemaContent) ContextValidate 

func (m *IntotoV002SchemaContent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v002 schema content based on the context it is used

func (*IntotoV002SchemaContent) MarshalBinary 

func (m *IntotoV002SchemaContent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV002SchemaContent) UnmarshalBinary 

func (m *IntotoV002SchemaContent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV002SchemaContent) Validate 

func (m *IntotoV002SchemaContent) Validate(formats strfmt.Registry) error

Validate validates this intoto v002 schema content

type IntotoV002SchemaContentEnvelope 

type IntotoV002SchemaContentEnvelope struct {

	// payload of the envelope
	// Format: byte
	Payload strfmt.Base64 `json:"payload,omitempty"`

	// type describing the payload
	// Required: true
	PayloadType *string `json:"payloadType"`

	// collection of all signatures of the envelope's payload
	// Required: true
	// Min Items: 1
	Signatures []*IntotoV002SchemaContentEnvelopeSignaturesItems0 `json:"signatures"`
}

IntotoV002SchemaContentEnvelope dsse envelope

swagger:model IntotoV002SchemaContentEnvelope

func (*IntotoV002SchemaContentEnvelope) ContextValidate 

func (m *IntotoV002SchemaContentEnvelope) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v002 schema content envelope based on the context it is used

func (*IntotoV002SchemaContentEnvelope) MarshalBinary 

func (m *IntotoV002SchemaContentEnvelope) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV002SchemaContentEnvelope) UnmarshalBinary 

func (m *IntotoV002SchemaContentEnvelope) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV002SchemaContentEnvelope) Validate 

func (m *IntotoV002SchemaContentEnvelope) Validate(formats strfmt.Registry) error

Validate validates this intoto v002 schema content envelope

type IntotoV002SchemaContentEnvelopeSignaturesItems0 

type IntotoV002SchemaContentEnvelopeSignaturesItems0 struct {

	// optional id of the key used to create the signature
	Keyid string `json:"keyid,omitempty"`

	// public key that corresponds to this signature
	// Required: true
	// Format: byte
	PublicKey *strfmt.Base64 `json:"publicKey"`

	// signature of the payload
	// Required: true
	// Format: byte
	Sig *strfmt.Base64 `json:"sig"`
}

IntotoV002SchemaContentEnvelopeSignaturesItems0 a signature of the envelope's payload along with the public key for the signature

swagger:model IntotoV002SchemaContentEnvelopeSignaturesItems0

func (*IntotoV002SchemaContentEnvelopeSignaturesItems0) ContextValidate 

func (m *IntotoV002SchemaContentEnvelopeSignaturesItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this intoto v002 schema content envelope signatures items0 based on context it is used

func (*IntotoV002SchemaContentEnvelopeSignaturesItems0) MarshalBinary 

func (m *IntotoV002SchemaContentEnvelopeSignaturesItems0) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV002SchemaContentEnvelopeSignaturesItems0) UnmarshalBinary 

func (m *IntotoV002SchemaContentEnvelopeSignaturesItems0) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV002SchemaContentEnvelopeSignaturesItems0) Validate 

func (m *IntotoV002SchemaContentEnvelopeSignaturesItems0) Validate(formats strfmt.Registry) error

Validate validates this intoto v002 schema content envelope signatures items0

type IntotoV002SchemaContentHash 

type IntotoV002SchemaContentHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the archive
	// Required: true
	Value *string `json:"value"`
}

IntotoV002SchemaContentHash Specifies the hash algorithm and value encompassing the entire signed envelope

swagger:model IntotoV002SchemaContentHash

func (*IntotoV002SchemaContentHash) ContextValidate 

func (m *IntotoV002SchemaContentHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v002 schema content hash based on the context it is used

func (*IntotoV002SchemaContentHash) MarshalBinary 

func (m *IntotoV002SchemaContentHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV002SchemaContentHash) UnmarshalBinary 

func (m *IntotoV002SchemaContentHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV002SchemaContentHash) Validate 

func (m *IntotoV002SchemaContentHash) Validate(formats strfmt.Registry) error

Validate validates this intoto v002 schema content hash

type IntotoV002SchemaContentPayloadHash 

type IntotoV002SchemaContentPayloadHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value of the payload
	// Required: true
	Value *string `json:"value"`
}

IntotoV002SchemaContentPayloadHash Specifies the hash algorithm and value covering the payload within the DSSE envelope

swagger:model IntotoV002SchemaContentPayloadHash

func (*IntotoV002SchemaContentPayloadHash) ContextValidate 

func (m *IntotoV002SchemaContentPayloadHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this intoto v002 schema content payload hash based on the context it is used

func (*IntotoV002SchemaContentPayloadHash) MarshalBinary 

func (m *IntotoV002SchemaContentPayloadHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IntotoV002SchemaContentPayloadHash) UnmarshalBinary 

func (m *IntotoV002SchemaContentPayloadHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IntotoV002SchemaContentPayloadHash) Validate 

func (m *IntotoV002SchemaContentPayloadHash) Validate(formats strfmt.Registry) error

Validate validates this intoto v002 schema content payload hash

type Jar 

type Jar struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec JarSchema `json:"spec"`
}

Jar Java Archive (JAR)

swagger:model jar

func (*Jar) ContextValidate 

func (m *Jar) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this jar based on the context it is used

func (*Jar) Kind 

func (m *Jar) Kind() string

Kind gets the kind of this subtype

func (*Jar) MarshalBinary 

func (m *Jar) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Jar) MarshalJSON 

func (m Jar) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Jar) SetKind 

func (m *Jar) SetKind(val string)

SetKind sets the kind of this subtype

func (*Jar) UnmarshalBinary 

func (m *Jar) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Jar) UnmarshalJSON 

func (m *Jar) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Jar) Validate 

func (m *Jar) Validate(formats strfmt.Registry) error

Validate validates this jar

type JarSchema 

type JarSchema interface{}

JarSchema JAR Schema

Schema for JAR objects

swagger:model jarSchema

type JarV001Schema 

type JarV001Schema struct {

	// archive
	// Required: true
	Archive *JarV001SchemaArchive `json:"archive"`

	// signature
	Signature *JarV001SchemaSignature `json:"signature,omitempty"`
}

JarV001Schema JAR v0.0.1 Schema

Schema for JAR entries

swagger:model jarV001Schema

func (*JarV001Schema) ContextValidate 

func (m *JarV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this jar v001 schema based on the context it is used

func (*JarV001Schema) MarshalBinary 

func (m *JarV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*JarV001Schema) UnmarshalBinary 

func (m *JarV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*JarV001Schema) Validate 

func (m *JarV001Schema) Validate(formats strfmt.Registry) error

Validate validates this jar v001 schema

type JarV001SchemaArchive 

type JarV001SchemaArchive struct {

	// Specifies the archive inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *JarV001SchemaArchiveHash `json:"hash,omitempty"`
}

JarV001SchemaArchive Information about the archive associated with the entry

swagger:model JarV001SchemaArchive

func (*JarV001SchemaArchive) ContextValidate 

func (m *JarV001SchemaArchive) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this jar v001 schema archive based on the context it is used

func (*JarV001SchemaArchive) MarshalBinary 

func (m *JarV001SchemaArchive) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*JarV001SchemaArchive) UnmarshalBinary 

func (m *JarV001SchemaArchive) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*JarV001SchemaArchive) Validate 

func (m *JarV001SchemaArchive) Validate(formats strfmt.Registry) error

Validate validates this jar v001 schema archive

type JarV001SchemaArchiveHash 

type JarV001SchemaArchiveHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the archive
	// Required: true
	Value *string `json:"value"`
}

JarV001SchemaArchiveHash Specifies the hash algorithm and value encompassing the entire signed archive

swagger:model JarV001SchemaArchiveHash

func (*JarV001SchemaArchiveHash) ContextValidate 

func (m *JarV001SchemaArchiveHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this jar v001 schema archive hash based on context it is used

func (*JarV001SchemaArchiveHash) MarshalBinary 

func (m *JarV001SchemaArchiveHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*JarV001SchemaArchiveHash) UnmarshalBinary 

func (m *JarV001SchemaArchiveHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*JarV001SchemaArchiveHash) Validate 

func (m *JarV001SchemaArchiveHash) Validate(formats strfmt.Registry) error

Validate validates this jar v001 schema archive hash

type JarV001SchemaSignature 

type JarV001SchemaSignature struct {

	// Specifies the PKCS7 signature embedded within the JAR file
	// Required: true
	// Read Only: true
	// Format: byte
	Content strfmt.Base64 `json:"content"`

	// public key
	// Required: true
	PublicKey *JarV001SchemaSignaturePublicKey `json:"publicKey"`
}

JarV001SchemaSignature Information about the included signature in the JAR file

swagger:model JarV001SchemaSignature

func (*JarV001SchemaSignature) ContextValidate 

func (m *JarV001SchemaSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this jar v001 schema signature based on the context it is used

func (*JarV001SchemaSignature) MarshalBinary 

func (m *JarV001SchemaSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*JarV001SchemaSignature) UnmarshalBinary 

func (m *JarV001SchemaSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*JarV001SchemaSignature) Validate 

func (m *JarV001SchemaSignature) Validate(formats strfmt.Registry) error

Validate validates this jar v001 schema signature

type JarV001SchemaSignaturePublicKey 

type JarV001SchemaSignaturePublicKey struct {

	// Specifies the content of the X509 certificate containing the public key used to verify the signature
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

JarV001SchemaSignaturePublicKey The X509 certificate containing the public key JAR which verifies the signature of the JAR

swagger:model JarV001SchemaSignaturePublicKey

func (*JarV001SchemaSignaturePublicKey) ContextValidate 

func (m *JarV001SchemaSignaturePublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this jar v001 schema signature public key based on the context it is used

func (*JarV001SchemaSignaturePublicKey) MarshalBinary 

func (m *JarV001SchemaSignaturePublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*JarV001SchemaSignaturePublicKey) UnmarshalBinary 

func (m *JarV001SchemaSignaturePublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*JarV001SchemaSignaturePublicKey) Validate 

func (m *JarV001SchemaSignaturePublicKey) Validate(formats strfmt.Registry) error

Validate validates this jar v001 schema signature public key

type LogEntry 

type LogEntry map[string]LogEntryAnon

LogEntry log entry

swagger:model LogEntry

func (LogEntry) ContextValidate 

func (m LogEntry) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this log entry based on the context it is used

func (LogEntry) Validate 

func (m LogEntry) Validate(formats strfmt.Registry) error

Validate validates this log entry

type LogEntryAnon 

type LogEntryAnon struct {

	// attestation
	Attestation *LogEntryAnonAttestation `json:"attestation,omitempty"`

	// body
	// Required: true
	Body interface{} `json:"body"`

	// The time the entry was added to the log as a Unix timestamp in seconds
	// Required: true
	IntegratedTime *int64 `json:"integratedTime"`

	// This is the SHA256 hash of the DER-encoded public key for the log at the time the entry was included in the log
	// Required: true
	// Pattern: ^[0-9a-fA-F]{64}$
	LogID *string `json:"logID"`

	// log index
	// Required: true
	// Minimum: 0
	LogIndex *int64 `json:"logIndex"`

	// verification
	Verification *LogEntryAnonVerification `json:"verification,omitempty"`
}

LogEntryAnon log entry anon

swagger:model LogEntryAnon

func (*LogEntryAnon) ContextValidate 

func (m *LogEntryAnon) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this log entry anon based on the context it is used

func (*LogEntryAnon) MarshalBinary 

func (m *LogEntryAnon) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogEntryAnon) UnmarshalBinary 

func (m *LogEntryAnon) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogEntryAnon) Validate 

func (m *LogEntryAnon) Validate(formats strfmt.Registry) error

Validate validates this log entry anon

type LogEntryAnonAttestation 

type LogEntryAnonAttestation struct {

	// data
	// Format: byte
	Data strfmt.Base64 `json:"data,omitempty"`
}

LogEntryAnonAttestation log entry anon attestation

swagger:model LogEntryAnonAttestation

func (*LogEntryAnonAttestation) ContextValidate 

func (m *LogEntryAnonAttestation) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this log entry anon attestation based on context it is used

func (*LogEntryAnonAttestation) MarshalBinary 

func (m *LogEntryAnonAttestation) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogEntryAnonAttestation) UnmarshalBinary 

func (m *LogEntryAnonAttestation) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogEntryAnonAttestation) Validate 

func (m *LogEntryAnonAttestation) Validate(formats strfmt.Registry) error

Validate validates this log entry anon attestation

type LogEntryAnonVerification 

type LogEntryAnonVerification struct {

	// inclusion proof
	InclusionProof *InclusionProof `json:"inclusionProof,omitempty"`

	// Signature over the logID, logIndex, body and integratedTime.
	// Format: byte
	SignedEntryTimestamp strfmt.Base64 `json:"signedEntryTimestamp,omitempty"`
}

LogEntryAnonVerification log entry anon verification

swagger:model LogEntryAnonVerification

func (*LogEntryAnonVerification) ContextValidate 

func (m *LogEntryAnonVerification) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this log entry anon verification based on the context it is used

func (*LogEntryAnonVerification) MarshalBinary 

func (m *LogEntryAnonVerification) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogEntryAnonVerification) UnmarshalBinary 

func (m *LogEntryAnonVerification) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogEntryAnonVerification) Validate 

func (m *LogEntryAnonVerification) Validate(formats strfmt.Registry) error

Validate validates this log entry anon verification

type LogInfo 

type LogInfo struct {

	// inactive shards
	InactiveShards []*InactiveShardLogInfo `json:"inactiveShards"`

	// The current hash value stored at the root of the merkle tree
	// Required: true
	// Pattern: ^[0-9a-fA-F]{64}$
	RootHash *string `json:"rootHash"`

	// The current signed tree head
	// Required: true
	SignedTreeHead *string `json:"signedTreeHead"`

	// The current treeID
	// Required: true
	// Pattern: ^[0-9]+$
	TreeID *string `json:"treeID"`

	// The current number of nodes in the merkle tree
	// Required: true
	// Minimum: 1
	TreeSize *int64 `json:"treeSize"`
}

LogInfo log info

swagger:model LogInfo

func (*LogInfo) ContextValidate 

func (m *LogInfo) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this log info based on the context it is used

func (*LogInfo) MarshalBinary 

func (m *LogInfo) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*LogInfo) UnmarshalBinary 

func (m *LogInfo) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*LogInfo) Validate 

func (m *LogInfo) Validate(formats strfmt.Registry) error

Validate validates this log info

type Participantrecord 

type Participantrecord struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec *ParticipantrecordV001Schema `json:"spec"`
}

Participantrecord Participantrecord object

swagger:model participantrecord

func (*Participantrecord) ContextValidate 

func (m *Participantrecord) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this participantrecord based on the context it is used

func (*Participantrecord) Kind 

func (m *Participantrecord) Kind() string

Kind gets the kind of this subtype

func (*Participantrecord) MarshalBinary 

func (m *Participantrecord) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Participantrecord) MarshalJSON 

func (m Participantrecord) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Participantrecord) SetKind 

func (m *Participantrecord) SetKind(val string)

SetKind sets the kind of this subtype

func (*Participantrecord) UnmarshalBinary 

func (m *Participantrecord) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Participantrecord) UnmarshalJSON 

func (m *Participantrecord) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Participantrecord) Validate 

func (m *Participantrecord) Validate(formats strfmt.Registry) error

Validate validates this participantrecord

type ParticipantrecordSchema 

type ParticipantrecordSchema interface{}

ParticipantrecordSchema Participantrecord Schema

Schema for Participantrecord objects

swagger:model participantrecordSchema

type ParticipantrecordV001Schema 

type ParticipantrecordV001Schema struct {

	// Alternate public key (optional)
	AlternatePK string `json:"alternatePK,omitempty"`

	// ID of the participant
	// Required: true
	ParticipantID *string `json:"participantId"`

	// Primary public key
	// Required: true
	PrimaryPK *string `json:"primaryPK"`

	// Entry creation time in RFC3339 (ISO 8601)
	// Required: true
	EntryCreatedAt *time.Time `json:"createdAt"`
}

ParticipantrecordV001Schema Participantrecord v0.0.1 Schema

Schema for Participantrecord v0.0.1 object

swagger:model participantrecordV001Schema

func (*ParticipantrecordV001Schema) ContextValidate 

func (m *ParticipantrecordV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this participantrecord v001 schema based on context it is used

func (*ParticipantrecordV001Schema) MarshalBinary 

func (m *ParticipantrecordV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ParticipantrecordV001Schema) UnmarshalBinary 

func (m *ParticipantrecordV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ParticipantrecordV001Schema) Validate 

func (m *ParticipantrecordV001Schema) Validate(formats strfmt.Registry) error

Validate validates this participantrecord v001 schema

type PkgTypesAlpineV001AlpineV001Schema 

type PkgTypesAlpineV001AlpineV001Schema struct {

	// package
	// Required: true
	Package *PkgTypesAlpineV001AlpineV001SchemaPackage `json:"package"`

	// public key
	// Required: true
	PublicKey *PkgTypesAlpineV001AlpineV001SchemaPublicKey `json:"publicKey"`
}

PkgTypesAlpineV001AlpineV001Schema Alpine v0.0.1 Schema

Schema for Alpine Package entries

swagger:model pkgTypesAlpineV001AlpineV001Schema

func (*PkgTypesAlpineV001AlpineV001Schema) ContextValidate 

func (m *PkgTypesAlpineV001AlpineV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types alpine v001 alpine v001 schema based on the context it is used

func (*PkgTypesAlpineV001AlpineV001Schema) MarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001Schema) UnmarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001Schema) Validate 

func (m *PkgTypesAlpineV001AlpineV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types alpine v001 alpine v001 schema

type PkgTypesAlpineV001AlpineV001SchemaPackage 

type PkgTypesAlpineV001AlpineV001SchemaPackage struct {

	// Specifies the package inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *PkgTypesAlpineV001AlpineV001SchemaPackageHash `json:"hash,omitempty"`

	// Values of the .PKGINFO key / value pairs
	// Read Only: true
	Pkginfo map[string]string `json:"pkginfo,omitempty"`
}

PkgTypesAlpineV001AlpineV001SchemaPackage Information about the package associated with the entry

swagger:model PkgTypesAlpineV001AlpineV001SchemaPackage

func (*PkgTypesAlpineV001AlpineV001SchemaPackage) ContextValidate 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types alpine v001 alpine v001 schema package based on the context it is used

func (*PkgTypesAlpineV001AlpineV001SchemaPackage) MarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001SchemaPackage) UnmarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001SchemaPackage) Validate 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackage) Validate(formats strfmt.Registry) error

Validate validates this pkg types alpine v001 alpine v001 schema package

type PkgTypesAlpineV001AlpineV001SchemaPackageHash 

type PkgTypesAlpineV001AlpineV001SchemaPackageHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the package
	// Required: true
	Value *string `json:"value"`
}

PkgTypesAlpineV001AlpineV001SchemaPackageHash Specifies the hash algorithm and value for the package

swagger:model PkgTypesAlpineV001AlpineV001SchemaPackageHash

func (*PkgTypesAlpineV001AlpineV001SchemaPackageHash) ContextValidate 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackageHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types alpine v001 alpine v001 schema package hash based on the context it is used

func (*PkgTypesAlpineV001AlpineV001SchemaPackageHash) MarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackageHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001SchemaPackageHash) UnmarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackageHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001SchemaPackageHash) Validate 

func (m *PkgTypesAlpineV001AlpineV001SchemaPackageHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types alpine v001 alpine v001 schema package hash

type PkgTypesAlpineV001AlpineV001SchemaPublicKey 

type PkgTypesAlpineV001AlpineV001SchemaPublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

PkgTypesAlpineV001AlpineV001SchemaPublicKey The public key that can verify the package signature

swagger:model PkgTypesAlpineV001AlpineV001SchemaPublicKey

func (*PkgTypesAlpineV001AlpineV001SchemaPublicKey) ContextValidate 

func (m *PkgTypesAlpineV001AlpineV001SchemaPublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types alpine v001 alpine v001 schema public key based on context it is used

func (*PkgTypesAlpineV001AlpineV001SchemaPublicKey) MarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001SchemaPublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001SchemaPublicKey) UnmarshalBinary 

func (m *PkgTypesAlpineV001AlpineV001SchemaPublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesAlpineV001AlpineV001SchemaPublicKey) Validate 

func (m *PkgTypesAlpineV001AlpineV001SchemaPublicKey) Validate(formats strfmt.Registry) error

Validate validates this pkg types alpine v001 alpine v001 schema public key

type PkgTypesCoseV001CoseV001Schema 

type PkgTypesCoseV001CoseV001Schema struct {

	// data
	Data *PkgTypesCoseV001CoseV001SchemaData `json:"data,omitempty"`

	// The COSE Sign1 Message
	// Format: byte
	Message strfmt.Base64 `json:"message,omitempty"`

	// The public key that can verify the signature
	// Required: true
	// Format: byte
	PublicKey *strfmt.Base64 `json:"publicKey"`
}

PkgTypesCoseV001CoseV001Schema cose v0.0.1 Schema

Schema for cose object

swagger:model pkgTypesCoseV001CoseV001Schema

func (*PkgTypesCoseV001CoseV001Schema) ContextValidate 

func (m *PkgTypesCoseV001CoseV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types cose v001 cose v001 schema based on the context it is used

func (*PkgTypesCoseV001CoseV001Schema) MarshalBinary 

func (m *PkgTypesCoseV001CoseV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001Schema) UnmarshalBinary 

func (m *PkgTypesCoseV001CoseV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001Schema) Validate 

func (m *PkgTypesCoseV001CoseV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types cose v001 cose v001 schema

type PkgTypesCoseV001CoseV001SchemaData 

type PkgTypesCoseV001CoseV001SchemaData struct {

	// Specifies the additional authenticated data required to verify the signature
	// Format: byte
	Aad strfmt.Base64 `json:"aad,omitempty"`

	// envelope hash
	EnvelopeHash *PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash `json:"envelopeHash,omitempty"`

	// payload hash
	PayloadHash *PkgTypesCoseV001CoseV001SchemaDataPayloadHash `json:"payloadHash,omitempty"`
}

PkgTypesCoseV001CoseV001SchemaData Information about the content associated with the entry

swagger:model PkgTypesCoseV001CoseV001SchemaData

func (*PkgTypesCoseV001CoseV001SchemaData) ContextValidate 

func (m *PkgTypesCoseV001CoseV001SchemaData) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types cose v001 cose v001 schema data based on the context it is used

func (*PkgTypesCoseV001CoseV001SchemaData) MarshalBinary 

func (m *PkgTypesCoseV001CoseV001SchemaData) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001SchemaData) UnmarshalBinary 

func (m *PkgTypesCoseV001CoseV001SchemaData) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001SchemaData) Validate 

func (m *PkgTypesCoseV001CoseV001SchemaData) Validate(formats strfmt.Registry) error

Validate validates this pkg types cose v001 cose v001 schema data

type PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash 

type PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the envelope
	// Required: true
	Value *string `json:"value"`
}

PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash Specifies the hash algorithm and value for the COSE envelope

swagger:model PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash

func (*PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) ContextValidate 

func (m *PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types cose v001 cose v001 schema data envelope hash based on the context it is used

func (*PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) MarshalBinary 

func (m *PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) UnmarshalBinary 

func (m *PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) Validate 

func (m *PkgTypesCoseV001CoseV001SchemaDataEnvelopeHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types cose v001 cose v001 schema data envelope hash

type PkgTypesCoseV001CoseV001SchemaDataPayloadHash 

type PkgTypesCoseV001CoseV001SchemaDataPayloadHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the content
	// Required: true
	Value *string `json:"value"`
}

PkgTypesCoseV001CoseV001SchemaDataPayloadHash Specifies the hash algorithm and value for the content

swagger:model PkgTypesCoseV001CoseV001SchemaDataPayloadHash

func (*PkgTypesCoseV001CoseV001SchemaDataPayloadHash) ContextValidate 

func (m *PkgTypesCoseV001CoseV001SchemaDataPayloadHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types cose v001 cose v001 schema data payload hash based on the context it is used

func (*PkgTypesCoseV001CoseV001SchemaDataPayloadHash) MarshalBinary 

func (m *PkgTypesCoseV001CoseV001SchemaDataPayloadHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001SchemaDataPayloadHash) UnmarshalBinary 

func (m *PkgTypesCoseV001CoseV001SchemaDataPayloadHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesCoseV001CoseV001SchemaDataPayloadHash) Validate 

func (m *PkgTypesCoseV001CoseV001SchemaDataPayloadHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types cose v001 cose v001 schema data payload hash

type PkgTypesDsseV001DsseV001Schema 

type PkgTypesDsseV001DsseV001Schema struct {

	// envelope hash
	EnvelopeHash *PkgTypesDsseV001DsseV001SchemaEnvelopeHash `json:"envelopeHash,omitempty"`

	// payload hash
	PayloadHash *PkgTypesDsseV001DsseV001SchemaPayloadHash `json:"payloadHash,omitempty"`

	// proposed content
	ProposedContent *PkgTypesDsseV001DsseV001SchemaProposedContent `json:"proposedContent,omitempty"`

	// extracted collection of all signatures of the envelope's payload; elements will be sorted by lexicographical order of the base64 encoded signature strings
	// Read Only: true
	// Min Items: 1
	Signatures []*PkgTypesDsseV001DsseV001SchemaSignaturesItems0 `json:"signatures"`
}

PkgTypesDsseV001DsseV001Schema DSSE v0.0.1 Schema

Schema for DSSE envelopes

swagger:model pkgTypesDsseV001DsseV001Schema

func (*PkgTypesDsseV001DsseV001Schema) ContextValidate 

func (m *PkgTypesDsseV001DsseV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types dsse v001 dsse v001 schema based on the context it is used

func (*PkgTypesDsseV001DsseV001Schema) MarshalBinary 

func (m *PkgTypesDsseV001DsseV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001Schema) UnmarshalBinary 

func (m *PkgTypesDsseV001DsseV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001Schema) Validate 

func (m *PkgTypesDsseV001DsseV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types dsse v001 dsse v001 schema

type PkgTypesDsseV001DsseV001SchemaEnvelopeHash 

type PkgTypesDsseV001DsseV001SchemaEnvelopeHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The value of the computed digest over the entire envelope
	// Required: true
	Value *string `json:"value"`
}

PkgTypesDsseV001DsseV001SchemaEnvelopeHash Specifies the hash algorithm and value encompassing the entire envelope sent to Rekor

swagger:model PkgTypesDsseV001DsseV001SchemaEnvelopeHash

func (*PkgTypesDsseV001DsseV001SchemaEnvelopeHash) ContextValidate 

func (m *PkgTypesDsseV001DsseV001SchemaEnvelopeHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types dsse v001 dsse v001 schema envelope hash based on the context it is used

func (*PkgTypesDsseV001DsseV001SchemaEnvelopeHash) MarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaEnvelopeHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaEnvelopeHash) UnmarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaEnvelopeHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaEnvelopeHash) Validate 

func (m *PkgTypesDsseV001DsseV001SchemaEnvelopeHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types dsse v001 dsse v001 schema envelope hash

type PkgTypesDsseV001DsseV001SchemaPayloadHash 

type PkgTypesDsseV001DsseV001SchemaPayloadHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The value of the computed digest over the payload within the envelope
	// Required: true
	Value *string `json:"value"`
}

PkgTypesDsseV001DsseV001SchemaPayloadHash Specifies the hash algorithm and value covering the payload within the DSSE envelope

swagger:model PkgTypesDsseV001DsseV001SchemaPayloadHash

func (*PkgTypesDsseV001DsseV001SchemaPayloadHash) ContextValidate 

func (m *PkgTypesDsseV001DsseV001SchemaPayloadHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types dsse v001 dsse v001 schema payload hash based on the context it is used

func (*PkgTypesDsseV001DsseV001SchemaPayloadHash) MarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaPayloadHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaPayloadHash) UnmarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaPayloadHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaPayloadHash) Validate 

func (m *PkgTypesDsseV001DsseV001SchemaPayloadHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types dsse v001 dsse v001 schema payload hash

type PkgTypesDsseV001DsseV001SchemaProposedContent 

type PkgTypesDsseV001DsseV001SchemaProposedContent struct {

	// DSSE envelope specified as a stringified JSON object
	// Required: true
	Envelope *string `json:"envelope"`

	// collection of all verification material (e.g. public keys or certificates) used to verify signatures over envelope's payload, specified as base64-encoded strings
	// Required: true
	// Min Items: 1
	Verifiers []strfmt.Base64 `json:"verifiers"`
}

PkgTypesDsseV001DsseV001SchemaProposedContent pkg types dsse v001 dsse v001 schema proposed content

swagger:model PkgTypesDsseV001DsseV001SchemaProposedContent

func (*PkgTypesDsseV001DsseV001SchemaProposedContent) ContextValidate 

func (m *PkgTypesDsseV001DsseV001SchemaProposedContent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types dsse v001 dsse v001 schema proposed content based on context it is used

func (*PkgTypesDsseV001DsseV001SchemaProposedContent) MarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaProposedContent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaProposedContent) UnmarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaProposedContent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaProposedContent) Validate 

func (m *PkgTypesDsseV001DsseV001SchemaProposedContent) Validate(formats strfmt.Registry) error

Validate validates this pkg types dsse v001 dsse v001 schema proposed content

type PkgTypesDsseV001DsseV001SchemaSignaturesItems0 

type PkgTypesDsseV001DsseV001SchemaSignaturesItems0 struct {

	// base64 encoded signature of the payload
	// Required: true
	// Pattern: ^(?:[A-Za-z0-9+\/]{4})*(?:[A-Za-z0-9+\/]{2}==|[A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{4})$
	Signature *string `json:"signature"`

	// verification material that was used to verify the corresponding signature, specified as a base64 encoded string
	// Required: true
	// Format: byte
	Verifier *strfmt.Base64 `json:"verifier"`
}

PkgTypesDsseV001DsseV001SchemaSignaturesItems0 a signature of the envelope's payload along with the verification material for the signature

swagger:model PkgTypesDsseV001DsseV001SchemaSignaturesItems0

func (*PkgTypesDsseV001DsseV001SchemaSignaturesItems0) ContextValidate 

func (m *PkgTypesDsseV001DsseV001SchemaSignaturesItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types dsse v001 dsse v001 schema signatures items0 based on context it is used

func (*PkgTypesDsseV001DsseV001SchemaSignaturesItems0) MarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaSignaturesItems0) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaSignaturesItems0) UnmarshalBinary 

func (m *PkgTypesDsseV001DsseV001SchemaSignaturesItems0) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesDsseV001DsseV001SchemaSignaturesItems0) Validate 

func (m *PkgTypesDsseV001DsseV001SchemaSignaturesItems0) Validate(formats strfmt.Registry) error

Validate validates this pkg types dsse v001 dsse v001 schema signatures items0

type PkgTypesHashedrekordV001HashedrekordV001Schema 

type PkgTypesHashedrekordV001HashedrekordV001Schema struct {

	// data
	// Required: true
	Data *PkgTypesHashedrekordV001HashedrekordV001SchemaData `json:"data"`

	// signature
	// Required: true
	Signature *PkgTypesHashedrekordV001HashedrekordV001SchemaSignature `json:"signature"`
}

PkgTypesHashedrekordV001HashedrekordV001Schema Hashed Rekor v0.0.1 Schema

Schema for Hashed Rekord object

swagger:model pkgTypesHashedrekordV001HashedrekordV001Schema

func (*PkgTypesHashedrekordV001HashedrekordV001Schema) ContextValidate 

func (m *PkgTypesHashedrekordV001HashedrekordV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types hashedrekord v001 hashedrekord v001 schema based on the context it is used

func (*PkgTypesHashedrekordV001HashedrekordV001Schema) MarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001Schema) UnmarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001Schema) Validate 

func (m *PkgTypesHashedrekordV001HashedrekordV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types hashedrekord v001 hashedrekord v001 schema

type PkgTypesHashedrekordV001HashedrekordV001SchemaData 

type PkgTypesHashedrekordV001HashedrekordV001SchemaData struct {

	// hash
	Hash *PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash `json:"hash,omitempty"`
}

PkgTypesHashedrekordV001HashedrekordV001SchemaData Information about the content associated with the entry

swagger:model PkgTypesHashedrekordV001HashedrekordV001SchemaData

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaData) ContextValidate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaData) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types hashedrekord v001 hashedrekord v001 schema data based on the context it is used

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaData) MarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaData) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaData) UnmarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaData) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaData) Validate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaData) Validate(formats strfmt.Registry) error

Validate validates this pkg types hashedrekord v001 hashedrekord v001 schema data

type PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash 

type PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256","sha384","sha512"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the content, as represented by a lower case hexadecimal string
	// Required: true
	Value *string `json:"value"`
}

PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash Specifies the hash algorithm and value for the content

swagger:model PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) ContextValidate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types hashedrekord v001 hashedrekord v001 schema data hash based on context it is used

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) MarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) UnmarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) Validate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaDataHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types hashedrekord v001 hashedrekord v001 schema data hash

type PkgTypesHashedrekordV001HashedrekordV001SchemaSignature 

type PkgTypesHashedrekordV001HashedrekordV001SchemaSignature struct {

	// Specifies the content of the signature inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// public key
	PublicKey *PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey `json:"publicKey,omitempty"`
}

PkgTypesHashedrekordV001HashedrekordV001SchemaSignature Information about the detached signature associated with the entry

swagger:model PkgTypesHashedrekordV001HashedrekordV001SchemaSignature

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) ContextValidate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types hashedrekord v001 hashedrekord v001 schema signature based on the context it is used

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) MarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) UnmarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) Validate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignature) Validate(formats strfmt.Registry) error

Validate validates this pkg types hashedrekord v001 hashedrekord v001 schema signature

type PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey 

type PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey struct {

	// Specifies the content of the public key or code signing certificate inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`
}

PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey The public key that can verify the signature; this can also be an X509 code signing certificate that contains the raw public key information

swagger:model PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) ContextValidate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types hashedrekord v001 hashedrekord v001 schema signature public key based on context it is used

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) MarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) UnmarshalBinary 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) Validate 

func (m *PkgTypesHashedrekordV001HashedrekordV001SchemaSignaturePublicKey) Validate(formats strfmt.Registry) error

Validate validates this pkg types hashedrekord v001 hashedrekord v001 schema signature public key

type PkgTypesHelmV001HelmV001Schema 

type PkgTypesHelmV001HelmV001Schema struct {

	// chart
	// Required: true
	Chart *PkgTypesHelmV001HelmV001SchemaChart `json:"chart"`

	// public key
	// Required: true
	PublicKey *PkgTypesHelmV001HelmV001SchemaPublicKey `json:"publicKey"`
}

PkgTypesHelmV001HelmV001Schema Helm v0.0.1 Schema

Schema for Helm object

swagger:model pkgTypesHelmV001HelmV001Schema

func (*PkgTypesHelmV001HelmV001Schema) ContextValidate 

func (m *PkgTypesHelmV001HelmV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types helm v001 helm v001 schema based on the context it is used

func (*PkgTypesHelmV001HelmV001Schema) MarshalBinary 

func (m *PkgTypesHelmV001HelmV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001Schema) UnmarshalBinary 

func (m *PkgTypesHelmV001HelmV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001Schema) Validate 

func (m *PkgTypesHelmV001HelmV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types helm v001 helm v001 schema

type PkgTypesHelmV001HelmV001SchemaChart 

type PkgTypesHelmV001HelmV001SchemaChart struct {

	// hash
	Hash *PkgTypesHelmV001HelmV001SchemaChartHash `json:"hash,omitempty"`

	// provenance
	// Required: true
	Provenance *PkgTypesHelmV001HelmV001SchemaChartProvenance `json:"provenance"`
}

PkgTypesHelmV001HelmV001SchemaChart Information about the Helm chart associated with the entry

swagger:model PkgTypesHelmV001HelmV001SchemaChart

func (*PkgTypesHelmV001HelmV001SchemaChart) ContextValidate 

func (m *PkgTypesHelmV001HelmV001SchemaChart) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types helm v001 helm v001 schema chart based on the context it is used

func (*PkgTypesHelmV001HelmV001SchemaChart) MarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChart) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChart) UnmarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChart) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChart) Validate 

func (m *PkgTypesHelmV001HelmV001SchemaChart) Validate(formats strfmt.Registry) error

Validate validates this pkg types helm v001 helm v001 schema chart

type PkgTypesHelmV001HelmV001SchemaChartHash 

type PkgTypesHelmV001HelmV001SchemaChartHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the chart
	// Required: true
	Value *string `json:"value"`
}

PkgTypesHelmV001HelmV001SchemaChartHash Specifies the hash algorithm and value for the chart

swagger:model PkgTypesHelmV001HelmV001SchemaChartHash

func (*PkgTypesHelmV001HelmV001SchemaChartHash) ContextValidate 

func (m *PkgTypesHelmV001HelmV001SchemaChartHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types helm v001 helm v001 schema chart hash based on the context it is used

func (*PkgTypesHelmV001HelmV001SchemaChartHash) MarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChartHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChartHash) UnmarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChartHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChartHash) Validate 

func (m *PkgTypesHelmV001HelmV001SchemaChartHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types helm v001 helm v001 schema chart hash

type PkgTypesHelmV001HelmV001SchemaChartProvenance 

type PkgTypesHelmV001HelmV001SchemaChartProvenance struct {

	// Specifies the content of the provenance file inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// signature
	Signature *PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature `json:"signature,omitempty"`
}

PkgTypesHelmV001HelmV001SchemaChartProvenance The provenance entry associated with the signed Helm Chart

swagger:model PkgTypesHelmV001HelmV001SchemaChartProvenance

func (*PkgTypesHelmV001HelmV001SchemaChartProvenance) ContextValidate 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenance) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types helm v001 helm v001 schema chart provenance based on the context it is used

func (*PkgTypesHelmV001HelmV001SchemaChartProvenance) MarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenance) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChartProvenance) UnmarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenance) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChartProvenance) Validate 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenance) Validate(formats strfmt.Registry) error

Validate validates this pkg types helm v001 helm v001 schema chart provenance

type PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature 

type PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature struct {

	// Specifies the signature embedded within the provenance file
	// Required: true
	// Read Only: true
	// Format: byte
	Content strfmt.Base64 `json:"content"`
}

PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature Information about the included signature in the provenance file

swagger:model PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature

func (*PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) ContextValidate 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types helm v001 helm v001 schema chart provenance signature based on the context it is used

func (*PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) MarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) UnmarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) Validate 

func (m *PkgTypesHelmV001HelmV001SchemaChartProvenanceSignature) Validate(formats strfmt.Registry) error

Validate validates this pkg types helm v001 helm v001 schema chart provenance signature

type PkgTypesHelmV001HelmV001SchemaPublicKey 

type PkgTypesHelmV001HelmV001SchemaPublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

PkgTypesHelmV001HelmV001SchemaPublicKey The public key that can verify the package signature

swagger:model PkgTypesHelmV001HelmV001SchemaPublicKey

func (*PkgTypesHelmV001HelmV001SchemaPublicKey) ContextValidate 

func (m *PkgTypesHelmV001HelmV001SchemaPublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types helm v001 helm v001 schema public key based on context it is used

func (*PkgTypesHelmV001HelmV001SchemaPublicKey) MarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaPublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaPublicKey) UnmarshalBinary 

func (m *PkgTypesHelmV001HelmV001SchemaPublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesHelmV001HelmV001SchemaPublicKey) Validate 

func (m *PkgTypesHelmV001HelmV001SchemaPublicKey) Validate(formats strfmt.Registry) error

Validate validates this pkg types helm v001 helm v001 schema public key

type PkgTypesIntotoV001IntotoV001Schema 

type PkgTypesIntotoV001IntotoV001Schema struct {

	// content
	// Required: true
	Content *PkgTypesIntotoV001IntotoV001SchemaContent `json:"content"`

	// The public key that can verify the signature
	// Required: true
	// Format: byte
	PublicKey *strfmt.Base64 `json:"publicKey"`
}

PkgTypesIntotoV001IntotoV001Schema intoto v0.0.1 Schema

Schema for intoto object

swagger:model pkgTypesIntotoV001IntotoV001Schema

func (*PkgTypesIntotoV001IntotoV001Schema) ContextValidate 

func (m *PkgTypesIntotoV001IntotoV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v001 intoto v001 schema based on the context it is used

func (*PkgTypesIntotoV001IntotoV001Schema) MarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001Schema) UnmarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001Schema) Validate 

func (m *PkgTypesIntotoV001IntotoV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v001 intoto v001 schema

type PkgTypesIntotoV001IntotoV001SchemaContent 

type PkgTypesIntotoV001IntotoV001SchemaContent struct {

	// envelope
	Envelope string `json:"envelope,omitempty"`

	// hash
	Hash *PkgTypesIntotoV001IntotoV001SchemaContentHash `json:"hash,omitempty"`

	// payload hash
	PayloadHash *PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash `json:"payloadHash,omitempty"`
}

PkgTypesIntotoV001IntotoV001SchemaContent pkg types intoto v001 intoto v001 schema content

swagger:model PkgTypesIntotoV001IntotoV001SchemaContent

func (*PkgTypesIntotoV001IntotoV001SchemaContent) ContextValidate 

func (m *PkgTypesIntotoV001IntotoV001SchemaContent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v001 intoto v001 schema content based on the context it is used

func (*PkgTypesIntotoV001IntotoV001SchemaContent) MarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001SchemaContent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001SchemaContent) UnmarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001SchemaContent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001SchemaContent) Validate 

func (m *PkgTypesIntotoV001IntotoV001SchemaContent) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v001 intoto v001 schema content

type PkgTypesIntotoV001IntotoV001SchemaContentHash 

type PkgTypesIntotoV001IntotoV001SchemaContentHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the archive
	// Required: true
	Value *string `json:"value"`
}

PkgTypesIntotoV001IntotoV001SchemaContentHash Specifies the hash algorithm and value encompassing the entire signed envelope; this is computed by the rekor server, client-provided values are ignored

swagger:model PkgTypesIntotoV001IntotoV001SchemaContentHash

func (*PkgTypesIntotoV001IntotoV001SchemaContentHash) ContextValidate 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v001 intoto v001 schema content hash based on the context it is used

func (*PkgTypesIntotoV001IntotoV001SchemaContentHash) MarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001SchemaContentHash) UnmarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001SchemaContentHash) Validate 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v001 intoto v001 schema content hash

type PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash 

type PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the envelope's payload
	// Required: true
	Value *string `json:"value"`
}

PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash Specifies the hash algorithm and value covering the payload within the DSSE envelope; this is computed by the rekor server, client-provided values are ignored

swagger:model PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash

func (*PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) ContextValidate 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v001 intoto v001 schema content payload hash based on the context it is used

func (*PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) MarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) UnmarshalBinary 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) Validate 

func (m *PkgTypesIntotoV001IntotoV001SchemaContentPayloadHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v001 intoto v001 schema content payload hash

type PkgTypesIntotoV002IntotoV002Schema 

type PkgTypesIntotoV002IntotoV002Schema struct {

	// content
	// Required: true
	Content *PkgTypesIntotoV002IntotoV002SchemaContent `json:"content"`
}

PkgTypesIntotoV002IntotoV002Schema intoto v0.0.2 Schema

Schema for intoto object

swagger:model pkgTypesIntotoV002IntotoV002Schema

func (*PkgTypesIntotoV002IntotoV002Schema) ContextValidate 

func (m *PkgTypesIntotoV002IntotoV002Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v002 intoto v002 schema based on the context it is used

func (*PkgTypesIntotoV002IntotoV002Schema) MarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002Schema) UnmarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002Schema) Validate 

func (m *PkgTypesIntotoV002IntotoV002Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v002 intoto v002 schema

type PkgTypesIntotoV002IntotoV002SchemaContent 

type PkgTypesIntotoV002IntotoV002SchemaContent struct {

	// envelope
	// Required: true
	Envelope *PkgTypesIntotoV002IntotoV002SchemaContentEnvelope `json:"envelope"`

	// hash
	Hash *PkgTypesIntotoV002IntotoV002SchemaContentHash `json:"hash,omitempty"`

	// payload hash
	PayloadHash *PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash `json:"payloadHash,omitempty"`
}

PkgTypesIntotoV002IntotoV002SchemaContent pkg types intoto v002 intoto v002 schema content

swagger:model PkgTypesIntotoV002IntotoV002SchemaContent

func (*PkgTypesIntotoV002IntotoV002SchemaContent) ContextValidate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContent) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v002 intoto v002 schema content based on the context it is used

func (*PkgTypesIntotoV002IntotoV002SchemaContent) MarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContent) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContent) UnmarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContent) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContent) Validate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContent) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v002 intoto v002 schema content

type PkgTypesIntotoV002IntotoV002SchemaContentEnvelope 

type PkgTypesIntotoV002IntotoV002SchemaContentEnvelope struct {

	// payload of the envelope
	// Format: byte
	Payload strfmt.Base64 `json:"payload,omitempty"`

	// type describing the payload
	// Required: true
	PayloadType *string `json:"payloadType"`

	// collection of all signatures of the envelope's payload
	// Required: true
	// Min Items: 1
	Signatures []*PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0 `json:"signatures"`
}

PkgTypesIntotoV002IntotoV002SchemaContentEnvelope dsse envelope

swagger:model PkgTypesIntotoV002IntotoV002SchemaContentEnvelope

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) ContextValidate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v002 intoto v002 schema content envelope based on the context it is used

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) MarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) UnmarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) Validate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelope) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v002 intoto v002 schema content envelope

type PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0 

type PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0 struct {

	// optional id of the key used to create the signature
	Keyid string `json:"keyid,omitempty"`

	// public key that corresponds to this signature
	// Required: true
	// Format: byte
	PublicKey *strfmt.Base64 `json:"publicKey"`

	// signature of the payload
	// Required: true
	// Format: byte
	Sig *strfmt.Base64 `json:"sig"`
}

PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0 a signature of the envelope's payload along with the public key for the signature

swagger:model PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) ContextValidate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types intoto v002 intoto v002 schema content envelope signatures items0 based on context it is used

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) MarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) UnmarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) Validate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentEnvelopeSignaturesItems0) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v002 intoto v002 schema content envelope signatures items0

type PkgTypesIntotoV002IntotoV002SchemaContentHash 

type PkgTypesIntotoV002IntotoV002SchemaContentHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the archive
	// Required: true
	Value *string `json:"value"`
}

PkgTypesIntotoV002IntotoV002SchemaContentHash Specifies the hash algorithm and value encompassing the entire signed envelope

swagger:model PkgTypesIntotoV002IntotoV002SchemaContentHash

func (*PkgTypesIntotoV002IntotoV002SchemaContentHash) ContextValidate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v002 intoto v002 schema content hash based on the context it is used

func (*PkgTypesIntotoV002IntotoV002SchemaContentHash) MarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentHash) UnmarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentHash) Validate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v002 intoto v002 schema content hash

type PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash 

type PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value of the payload
	// Required: true
	Value *string `json:"value"`
}

PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash Specifies the hash algorithm and value covering the payload within the DSSE envelope

swagger:model PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash

func (*PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) ContextValidate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types intoto v002 intoto v002 schema content payload hash based on the context it is used

func (*PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) MarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) UnmarshalBinary 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) Validate 

func (m *PkgTypesIntotoV002IntotoV002SchemaContentPayloadHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types intoto v002 intoto v002 schema content payload hash

type PkgTypesJarV001JarV001Schema 

type PkgTypesJarV001JarV001Schema struct {

	// archive
	// Required: true
	Archive *PkgTypesJarV001JarV001SchemaArchive `json:"archive"`

	// signature
	Signature *PkgTypesJarV001JarV001SchemaSignature `json:"signature,omitempty"`
}

PkgTypesJarV001JarV001Schema JAR v0.0.1 Schema

Schema for JAR entries

swagger:model pkgTypesJarV001JarV001Schema

func (*PkgTypesJarV001JarV001Schema) ContextValidate 

func (m *PkgTypesJarV001JarV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types jar v001 jar v001 schema based on the context it is used

func (*PkgTypesJarV001JarV001Schema) MarshalBinary 

func (m *PkgTypesJarV001JarV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesJarV001JarV001Schema) UnmarshalBinary 

func (m *PkgTypesJarV001JarV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesJarV001JarV001Schema) Validate 

func (m *PkgTypesJarV001JarV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types jar v001 jar v001 schema

type PkgTypesJarV001JarV001SchemaArchive 

type PkgTypesJarV001JarV001SchemaArchive struct {

	// Specifies the archive inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *PkgTypesJarV001JarV001SchemaArchiveHash `json:"hash,omitempty"`
}

PkgTypesJarV001JarV001SchemaArchive Information about the archive associated with the entry

swagger:model PkgTypesJarV001JarV001SchemaArchive

func (*PkgTypesJarV001JarV001SchemaArchive) ContextValidate 

func (m *PkgTypesJarV001JarV001SchemaArchive) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types jar v001 jar v001 schema archive based on the context it is used

func (*PkgTypesJarV001JarV001SchemaArchive) MarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaArchive) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaArchive) UnmarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaArchive) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaArchive) Validate 

func (m *PkgTypesJarV001JarV001SchemaArchive) Validate(formats strfmt.Registry) error

Validate validates this pkg types jar v001 jar v001 schema archive

type PkgTypesJarV001JarV001SchemaArchiveHash 

type PkgTypesJarV001JarV001SchemaArchiveHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the archive
	// Required: true
	Value *string `json:"value"`
}

PkgTypesJarV001JarV001SchemaArchiveHash Specifies the hash algorithm and value encompassing the entire signed archive

swagger:model PkgTypesJarV001JarV001SchemaArchiveHash

func (*PkgTypesJarV001JarV001SchemaArchiveHash) ContextValidate 

func (m *PkgTypesJarV001JarV001SchemaArchiveHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types jar v001 jar v001 schema archive hash based on context it is used

func (*PkgTypesJarV001JarV001SchemaArchiveHash) MarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaArchiveHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaArchiveHash) UnmarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaArchiveHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaArchiveHash) Validate 

func (m *PkgTypesJarV001JarV001SchemaArchiveHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types jar v001 jar v001 schema archive hash

type PkgTypesJarV001JarV001SchemaSignature 

type PkgTypesJarV001JarV001SchemaSignature struct {

	// Specifies the PKCS7 signature embedded within the JAR file
	// Required: true
	// Read Only: true
	// Format: byte
	Content strfmt.Base64 `json:"content"`

	// public key
	// Required: true
	PublicKey *PkgTypesJarV001JarV001SchemaSignaturePublicKey `json:"publicKey"`
}

PkgTypesJarV001JarV001SchemaSignature Information about the included signature in the JAR file

swagger:model PkgTypesJarV001JarV001SchemaSignature

func (*PkgTypesJarV001JarV001SchemaSignature) ContextValidate 

func (m *PkgTypesJarV001JarV001SchemaSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types jar v001 jar v001 schema signature based on the context it is used

func (*PkgTypesJarV001JarV001SchemaSignature) MarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaSignature) UnmarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaSignature) Validate 

func (m *PkgTypesJarV001JarV001SchemaSignature) Validate(formats strfmt.Registry) error

Validate validates this pkg types jar v001 jar v001 schema signature

type PkgTypesJarV001JarV001SchemaSignaturePublicKey 

type PkgTypesJarV001JarV001SchemaSignaturePublicKey struct {

	// Specifies the content of the X509 certificate containing the public key used to verify the signature
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

PkgTypesJarV001JarV001SchemaSignaturePublicKey The X509 certificate containing the public key JAR which verifies the signature of the JAR

swagger:model PkgTypesJarV001JarV001SchemaSignaturePublicKey

func (*PkgTypesJarV001JarV001SchemaSignaturePublicKey) ContextValidate 

func (m *PkgTypesJarV001JarV001SchemaSignaturePublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types jar v001 jar v001 schema signature public key based on the context it is used

func (*PkgTypesJarV001JarV001SchemaSignaturePublicKey) MarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaSignaturePublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaSignaturePublicKey) UnmarshalBinary 

func (m *PkgTypesJarV001JarV001SchemaSignaturePublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesJarV001JarV001SchemaSignaturePublicKey) Validate 

func (m *PkgTypesJarV001JarV001SchemaSignaturePublicKey) Validate(formats strfmt.Registry) error

Validate validates this pkg types jar v001 jar v001 schema signature public key

type PkgTypesParticipantrecordV001ParticipantrecordV001Schema 

type PkgTypesParticipantrecordV001ParticipantrecordV001Schema struct {

	// Alternate public key in PEM format (optional)
	// Format: byte
	AlternatePK strfmt.Base64 `json:"alternatePK,omitempty"`

	// Unique participant identifier
	// Required: true
	ParticipantID *string `json:"participantId"`

	// Primary public key in PEM format
	// Format: byte
	PrimaryPK *strfmt.Base64 `json:"primaryPK"`

	// Entry creation time in RFC3339 (ISO 8601)
	// Required: true
	EntryCreatedAt *time.Time `json:"createdAt"`
}

PkgTypesParticipantrecordV001ParticipantrecordV001Schema Participantrecord v0.0.1 Schema

Schema for Participantrecord object

swagger:model pkgTypesParticipantrecordV001ParticipantrecordV001Schema

func (*PkgTypesParticipantrecordV001ParticipantrecordV001Schema) ContextValidate 

func (m *PkgTypesParticipantrecordV001ParticipantrecordV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types participantrecord v001 participantrecord v001 schema based on context it is used

func (*PkgTypesParticipantrecordV001ParticipantrecordV001Schema) MarshalBinary 

func (m *PkgTypesParticipantrecordV001ParticipantrecordV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesParticipantrecordV001ParticipantrecordV001Schema) UnmarshalBinary 

func (m *PkgTypesParticipantrecordV001ParticipantrecordV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesParticipantrecordV001ParticipantrecordV001Schema) Validate 

func (m *PkgTypesParticipantrecordV001ParticipantrecordV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types participantrecord v001 participantrecord v001 schema

type PkgTypesRekordV001RekordV001Schema 

type PkgTypesRekordV001RekordV001Schema struct {

	// data
	// Required: true
	Data *PkgTypesRekordV001RekordV001SchemaData `json:"data"`

	// signature
	// Required: true
	Signature *PkgTypesRekordV001RekordV001SchemaSignature `json:"signature"`
}

PkgTypesRekordV001RekordV001Schema Rekor v0.0.1 Schema

Schema for Rekord object

swagger:model pkgTypesRekordV001RekordV001Schema

func (*PkgTypesRekordV001RekordV001Schema) ContextValidate 

func (m *PkgTypesRekordV001RekordV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types rekord v001 rekord v001 schema based on the context it is used

func (*PkgTypesRekordV001RekordV001Schema) MarshalBinary 

func (m *PkgTypesRekordV001RekordV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001Schema) UnmarshalBinary 

func (m *PkgTypesRekordV001RekordV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001Schema) Validate 

func (m *PkgTypesRekordV001RekordV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types rekord v001 rekord v001 schema

type PkgTypesRekordV001RekordV001SchemaData 

type PkgTypesRekordV001RekordV001SchemaData struct {

	// Specifies the content inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *PkgTypesRekordV001RekordV001SchemaDataHash `json:"hash,omitempty"`
}

PkgTypesRekordV001RekordV001SchemaData Information about the content associated with the entry

swagger:model PkgTypesRekordV001RekordV001SchemaData

func (*PkgTypesRekordV001RekordV001SchemaData) ContextValidate 

func (m *PkgTypesRekordV001RekordV001SchemaData) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types rekord v001 rekord v001 schema data based on the context it is used

func (*PkgTypesRekordV001RekordV001SchemaData) MarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaData) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaData) UnmarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaData) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaData) Validate 

func (m *PkgTypesRekordV001RekordV001SchemaData) Validate(formats strfmt.Registry) error

Validate validates this pkg types rekord v001 rekord v001 schema data

type PkgTypesRekordV001RekordV001SchemaDataHash 

type PkgTypesRekordV001RekordV001SchemaDataHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the content
	// Required: true
	Value *string `json:"value"`
}

PkgTypesRekordV001RekordV001SchemaDataHash Specifies the hash algorithm and value for the content

swagger:model PkgTypesRekordV001RekordV001SchemaDataHash

func (*PkgTypesRekordV001RekordV001SchemaDataHash) ContextValidate 

func (m *PkgTypesRekordV001RekordV001SchemaDataHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types rekord v001 rekord v001 schema data hash based on the context it is used

func (*PkgTypesRekordV001RekordV001SchemaDataHash) MarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaDataHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaDataHash) UnmarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaDataHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaDataHash) Validate 

func (m *PkgTypesRekordV001RekordV001SchemaDataHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types rekord v001 rekord v001 schema data hash

type PkgTypesRekordV001RekordV001SchemaSignature 

type PkgTypesRekordV001RekordV001SchemaSignature struct {

	// Specifies the content of the signature inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`

	// Specifies the format of the signature
	// Required: true
	// Enum: ["pgp","minisign","x509","ssh"]
	Format *string `json:"format"`

	// public key
	// Required: true
	PublicKey *PkgTypesRekordV001RekordV001SchemaSignaturePublicKey `json:"publicKey"`
}

PkgTypesRekordV001RekordV001SchemaSignature Information about the detached signature associated with the entry

swagger:model PkgTypesRekordV001RekordV001SchemaSignature

func (*PkgTypesRekordV001RekordV001SchemaSignature) ContextValidate 

func (m *PkgTypesRekordV001RekordV001SchemaSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types rekord v001 rekord v001 schema signature based on the context it is used

func (*PkgTypesRekordV001RekordV001SchemaSignature) MarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaSignature) UnmarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaSignature) Validate 

func (m *PkgTypesRekordV001RekordV001SchemaSignature) Validate(formats strfmt.Registry) error

Validate validates this pkg types rekord v001 rekord v001 schema signature

type PkgTypesRekordV001RekordV001SchemaSignaturePublicKey 

type PkgTypesRekordV001RekordV001SchemaSignaturePublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

PkgTypesRekordV001RekordV001SchemaSignaturePublicKey The public key that can verify the signature

swagger:model PkgTypesRekordV001RekordV001SchemaSignaturePublicKey

func (*PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) ContextValidate 

func (m *PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types rekord v001 rekord v001 schema signature public key based on context it is used

func (*PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) MarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) UnmarshalBinary 

func (m *PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) Validate 

func (m *PkgTypesRekordV001RekordV001SchemaSignaturePublicKey) Validate(formats strfmt.Registry) error

Validate validates this pkg types rekord v001 rekord v001 schema signature public key

type PkgTypesRfc3161V001Rfc3161V001Schema 

type PkgTypesRfc3161V001Rfc3161V001Schema struct {

	// tsr
	// Required: true
	Tsr *PkgTypesRfc3161V001Rfc3161V001SchemaTsr `json:"tsr"`
}

PkgTypesRfc3161V001Rfc3161V001Schema Timestamp v0.0.1 Schema

Schema for RFC3161 entries

swagger:model pkgTypesRfc3161V001Rfc3161V001Schema

func (*PkgTypesRfc3161V001Rfc3161V001Schema) ContextValidate 

func (m *PkgTypesRfc3161V001Rfc3161V001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types rfc3161 v001 rfc3161 v001 schema based on the context it is used

func (*PkgTypesRfc3161V001Rfc3161V001Schema) MarshalBinary 

func (m *PkgTypesRfc3161V001Rfc3161V001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRfc3161V001Rfc3161V001Schema) UnmarshalBinary 

func (m *PkgTypesRfc3161V001Rfc3161V001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRfc3161V001Rfc3161V001Schema) Validate 

func (m *PkgTypesRfc3161V001Rfc3161V001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types rfc3161 v001 rfc3161 v001 schema

type PkgTypesRfc3161V001Rfc3161V001SchemaTsr 

type PkgTypesRfc3161V001Rfc3161V001SchemaTsr struct {

	// Specifies the tsr file content inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

PkgTypesRfc3161V001Rfc3161V001SchemaTsr Information about the tsr file associated with the entry

swagger:model PkgTypesRfc3161V001Rfc3161V001SchemaTsr

func (*PkgTypesRfc3161V001Rfc3161V001SchemaTsr) ContextValidate 

func (m *PkgTypesRfc3161V001Rfc3161V001SchemaTsr) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types rfc3161 v001 rfc3161 v001 schema tsr based on context it is used

func (*PkgTypesRfc3161V001Rfc3161V001SchemaTsr) MarshalBinary 

func (m *PkgTypesRfc3161V001Rfc3161V001SchemaTsr) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRfc3161V001Rfc3161V001SchemaTsr) UnmarshalBinary 

func (m *PkgTypesRfc3161V001Rfc3161V001SchemaTsr) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRfc3161V001Rfc3161V001SchemaTsr) Validate 

func (m *PkgTypesRfc3161V001Rfc3161V001SchemaTsr) Validate(formats strfmt.Registry) error

Validate validates this pkg types rfc3161 v001 rfc3161 v001 schema tsr

type PkgTypesRpmV001RpmV001Schema 

type PkgTypesRpmV001RpmV001Schema struct {

	// package
	// Required: true
	Package *PkgTypesRpmV001RpmV001SchemaPackage `json:"package"`

	// public key
	// Required: true
	PublicKey *PkgTypesRpmV001RpmV001SchemaPublicKey `json:"publicKey"`
}

PkgTypesRpmV001RpmV001Schema RPM v0.0.1 Schema

Schema for RPM entries

swagger:model pkgTypesRpmV001RpmV001Schema

func (*PkgTypesRpmV001RpmV001Schema) ContextValidate 

func (m *PkgTypesRpmV001RpmV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types rpm v001 rpm v001 schema based on the context it is used

func (*PkgTypesRpmV001RpmV001Schema) MarshalBinary 

func (m *PkgTypesRpmV001RpmV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001Schema) UnmarshalBinary 

func (m *PkgTypesRpmV001RpmV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001Schema) Validate 

func (m *PkgTypesRpmV001RpmV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types rpm v001 rpm v001 schema

type PkgTypesRpmV001RpmV001SchemaPackage 

type PkgTypesRpmV001RpmV001SchemaPackage struct {

	// Specifies the package inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *PkgTypesRpmV001RpmV001SchemaPackageHash `json:"hash,omitempty"`

	// Values of the RPM headers
	// Read Only: true
	Headers map[string]string `json:"headers,omitempty"`
}

PkgTypesRpmV001RpmV001SchemaPackage Information about the package associated with the entry

swagger:model PkgTypesRpmV001RpmV001SchemaPackage

func (*PkgTypesRpmV001RpmV001SchemaPackage) ContextValidate 

func (m *PkgTypesRpmV001RpmV001SchemaPackage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types rpm v001 rpm v001 schema package based on the context it is used

func (*PkgTypesRpmV001RpmV001SchemaPackage) MarshalBinary 

func (m *PkgTypesRpmV001RpmV001SchemaPackage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001SchemaPackage) UnmarshalBinary 

func (m *PkgTypesRpmV001RpmV001SchemaPackage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001SchemaPackage) Validate 

func (m *PkgTypesRpmV001RpmV001SchemaPackage) Validate(formats strfmt.Registry) error

Validate validates this pkg types rpm v001 rpm v001 schema package

type PkgTypesRpmV001RpmV001SchemaPackageHash 

type PkgTypesRpmV001RpmV001SchemaPackageHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the package
	// Required: true
	Value *string `json:"value"`
}

PkgTypesRpmV001RpmV001SchemaPackageHash Specifies the hash algorithm and value for the package

swagger:model PkgTypesRpmV001RpmV001SchemaPackageHash

func (*PkgTypesRpmV001RpmV001SchemaPackageHash) ContextValidate 

func (m *PkgTypesRpmV001RpmV001SchemaPackageHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types rpm v001 rpm v001 schema package hash based on context it is used

func (*PkgTypesRpmV001RpmV001SchemaPackageHash) MarshalBinary 

func (m *PkgTypesRpmV001RpmV001SchemaPackageHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001SchemaPackageHash) UnmarshalBinary 

func (m *PkgTypesRpmV001RpmV001SchemaPackageHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001SchemaPackageHash) Validate 

func (m *PkgTypesRpmV001RpmV001SchemaPackageHash) Validate(formats strfmt.Registry) error

Validate validates this pkg types rpm v001 rpm v001 schema package hash

type PkgTypesRpmV001RpmV001SchemaPublicKey 

type PkgTypesRpmV001RpmV001SchemaPublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

PkgTypesRpmV001RpmV001SchemaPublicKey The PGP public key that can verify the RPM signature

swagger:model PkgTypesRpmV001RpmV001SchemaPublicKey

func (*PkgTypesRpmV001RpmV001SchemaPublicKey) ContextValidate 

func (m *PkgTypesRpmV001RpmV001SchemaPublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types rpm v001 rpm v001 schema public key based on context it is used

func (*PkgTypesRpmV001RpmV001SchemaPublicKey) MarshalBinary 

func (m *PkgTypesRpmV001RpmV001SchemaPublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001SchemaPublicKey) UnmarshalBinary 

func (m *PkgTypesRpmV001RpmV001SchemaPublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesRpmV001RpmV001SchemaPublicKey) Validate 

func (m *PkgTypesRpmV001RpmV001SchemaPublicKey) Validate(formats strfmt.Registry) error

Validate validates this pkg types rpm v001 rpm v001 schema public key

type PkgTypesTufV001TufV001Schema 

type PkgTypesTufV001TufV001Schema struct {

	// metadata
	// Required: true
	Metadata *PkgTypesTufV001TufV001SchemaMetadata `json:"metadata"`

	// root
	// Required: true
	Root *PkgTypesTufV001TufV001SchemaRoot `json:"root"`

	// TUF specification version
	// Read Only: true
	SpecVersion string `json:"spec_version,omitempty"`
}

PkgTypesTufV001TufV001Schema TUF v0.0.1 Schema

Schema for TUF metadata entries

swagger:model pkgTypesTufV001TufV001Schema

func (*PkgTypesTufV001TufV001Schema) ContextValidate 

func (m *PkgTypesTufV001TufV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this pkg types tuf v001 tuf v001 schema based on the context it is used

func (*PkgTypesTufV001TufV001Schema) MarshalBinary 

func (m *PkgTypesTufV001TufV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesTufV001TufV001Schema) UnmarshalBinary 

func (m *PkgTypesTufV001TufV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesTufV001TufV001Schema) Validate 

func (m *PkgTypesTufV001TufV001Schema) Validate(formats strfmt.Registry) error

Validate validates this pkg types tuf v001 tuf v001 schema

type PkgTypesTufV001TufV001SchemaMetadata 

type PkgTypesTufV001TufV001SchemaMetadata struct {

	// Specifies the metadata inline within the document
	// Required: true
	Content interface{} `json:"content"`
}

PkgTypesTufV001TufV001SchemaMetadata TUF metadata

swagger:model PkgTypesTufV001TufV001SchemaMetadata

func (*PkgTypesTufV001TufV001SchemaMetadata) ContextValidate 

func (m *PkgTypesTufV001TufV001SchemaMetadata) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types tuf v001 tuf v001 schema metadata based on context it is used

func (*PkgTypesTufV001TufV001SchemaMetadata) MarshalBinary 

func (m *PkgTypesTufV001TufV001SchemaMetadata) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesTufV001TufV001SchemaMetadata) UnmarshalBinary 

func (m *PkgTypesTufV001TufV001SchemaMetadata) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesTufV001TufV001SchemaMetadata) Validate 

func (m *PkgTypesTufV001TufV001SchemaMetadata) Validate(formats strfmt.Registry) error

Validate validates this pkg types tuf v001 tuf v001 schema metadata

type PkgTypesTufV001TufV001SchemaRoot 

type PkgTypesTufV001TufV001SchemaRoot struct {

	// Specifies the metadata inline within the document
	// Required: true
	Content interface{} `json:"content"`
}

PkgTypesTufV001TufV001SchemaRoot root metadata containing about the public keys used to sign the manifest

swagger:model PkgTypesTufV001TufV001SchemaRoot

func (*PkgTypesTufV001TufV001SchemaRoot) ContextValidate 

func (m *PkgTypesTufV001TufV001SchemaRoot) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this pkg types tuf v001 tuf v001 schema root based on context it is used

func (*PkgTypesTufV001TufV001SchemaRoot) MarshalBinary 

func (m *PkgTypesTufV001TufV001SchemaRoot) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PkgTypesTufV001TufV001SchemaRoot) UnmarshalBinary 

func (m *PkgTypesTufV001TufV001SchemaRoot) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PkgTypesTufV001TufV001SchemaRoot) Validate 

func (m *PkgTypesTufV001TufV001SchemaRoot) Validate(formats strfmt.Registry) error

Validate validates this pkg types tuf v001 tuf v001 schema root

type ProposedEntry 

type ProposedEntry interface {
	runtime.Validatable
	runtime.ContextValidatable

	// kind
	// Required: true
	Kind() string
	SetKind(string)
}

ProposedEntry proposed entry

swagger:discriminator ProposedEntry kind

func UnmarshalProposedEntry 

func UnmarshalProposedEntry(reader io.Reader, consumer runtime.Consumer) (ProposedEntry, error)

UnmarshalProposedEntry unmarshals polymorphic ProposedEntry

func UnmarshalProposedEntrySlice 

func UnmarshalProposedEntrySlice(reader io.Reader, consumer runtime.Consumer) ([]ProposedEntry, error)

UnmarshalProposedEntrySlice unmarshals polymorphic slices of ProposedEntry

type Rekord 

type Rekord struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec RekordSchema `json:"spec"`
}

Rekord Rekord object

swagger:model rekord

func (*Rekord) ContextValidate 

func (m *Rekord) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rekord based on the context it is used

func (*Rekord) Kind 

func (m *Rekord) Kind() string

Kind gets the kind of this subtype

func (*Rekord) MarshalBinary 

func (m *Rekord) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Rekord) MarshalJSON 

func (m Rekord) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Rekord) SetKind 

func (m *Rekord) SetKind(val string)

SetKind sets the kind of this subtype

func (*Rekord) UnmarshalBinary 

func (m *Rekord) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Rekord) UnmarshalJSON 

func (m *Rekord) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Rekord) Validate 

func (m *Rekord) Validate(formats strfmt.Registry) error

Validate validates this rekord

type RekordSchema 

type RekordSchema interface{}

RekordSchema Rekor Schema

Schema for Rekord objects

swagger:model rekordSchema

type RekordV001Schema 

type RekordV001Schema struct {

	// data
	// Required: true
	Data *RekordV001SchemaData `json:"data"`

	// signature
	// Required: true
	Signature *RekordV001SchemaSignature `json:"signature"`
}

RekordV001Schema Rekor v0.0.1 Schema

Schema for Rekord object

swagger:model rekordV001Schema

func (*RekordV001Schema) ContextValidate 

func (m *RekordV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rekord v001 schema based on the context it is used

func (*RekordV001Schema) MarshalBinary 

func (m *RekordV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RekordV001Schema) UnmarshalBinary 

func (m *RekordV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RekordV001Schema) Validate 

func (m *RekordV001Schema) Validate(formats strfmt.Registry) error

Validate validates this rekord v001 schema

type RekordV001SchemaData 

type RekordV001SchemaData struct {

	// Specifies the content inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *RekordV001SchemaDataHash `json:"hash,omitempty"`
}

RekordV001SchemaData Information about the content associated with the entry

swagger:model RekordV001SchemaData

func (*RekordV001SchemaData) ContextValidate 

func (m *RekordV001SchemaData) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rekord v001 schema data based on the context it is used

func (*RekordV001SchemaData) MarshalBinary 

func (m *RekordV001SchemaData) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RekordV001SchemaData) UnmarshalBinary 

func (m *RekordV001SchemaData) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RekordV001SchemaData) Validate 

func (m *RekordV001SchemaData) Validate(formats strfmt.Registry) error

Validate validates this rekord v001 schema data

type RekordV001SchemaDataHash 

type RekordV001SchemaDataHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the content
	// Required: true
	Value *string `json:"value"`
}

RekordV001SchemaDataHash Specifies the hash algorithm and value for the content

swagger:model RekordV001SchemaDataHash

func (*RekordV001SchemaDataHash) ContextValidate 

func (m *RekordV001SchemaDataHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rekord v001 schema data hash based on the context it is used

func (*RekordV001SchemaDataHash) MarshalBinary 

func (m *RekordV001SchemaDataHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RekordV001SchemaDataHash) UnmarshalBinary 

func (m *RekordV001SchemaDataHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RekordV001SchemaDataHash) Validate 

func (m *RekordV001SchemaDataHash) Validate(formats strfmt.Registry) error

Validate validates this rekord v001 schema data hash

type RekordV001SchemaSignature 

type RekordV001SchemaSignature struct {

	// Specifies the content of the signature inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`

	// Specifies the format of the signature
	// Required: true
	// Enum: ["pgp","minisign","x509","ssh"]
	Format *string `json:"format"`

	// public key
	// Required: true
	PublicKey *RekordV001SchemaSignaturePublicKey `json:"publicKey"`
}

RekordV001SchemaSignature Information about the detached signature associated with the entry

swagger:model RekordV001SchemaSignature

func (*RekordV001SchemaSignature) ContextValidate 

func (m *RekordV001SchemaSignature) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rekord v001 schema signature based on the context it is used

func (*RekordV001SchemaSignature) MarshalBinary 

func (m *RekordV001SchemaSignature) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RekordV001SchemaSignature) UnmarshalBinary 

func (m *RekordV001SchemaSignature) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RekordV001SchemaSignature) Validate 

func (m *RekordV001SchemaSignature) Validate(formats strfmt.Registry) error

Validate validates this rekord v001 schema signature

type RekordV001SchemaSignaturePublicKey 

type RekordV001SchemaSignaturePublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

RekordV001SchemaSignaturePublicKey The public key that can verify the signature

swagger:model RekordV001SchemaSignaturePublicKey

func (*RekordV001SchemaSignaturePublicKey) ContextValidate 

func (m *RekordV001SchemaSignaturePublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this rekord v001 schema signature public key based on context it is used

func (*RekordV001SchemaSignaturePublicKey) MarshalBinary 

func (m *RekordV001SchemaSignaturePublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RekordV001SchemaSignaturePublicKey) UnmarshalBinary 

func (m *RekordV001SchemaSignaturePublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RekordV001SchemaSignaturePublicKey) Validate 

func (m *RekordV001SchemaSignaturePublicKey) Validate(formats strfmt.Registry) error

Validate validates this rekord v001 schema signature public key

type Rfc3161 

type Rfc3161 struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec Rfc3161Schema `json:"spec"`
}

Rfc3161 RFC3161 Timestamp

swagger:model rfc3161

func (*Rfc3161) ContextValidate 

func (m *Rfc3161) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rfc3161 based on the context it is used

func (*Rfc3161) Kind 

func (m *Rfc3161) Kind() string

Kind gets the kind of this subtype

func (*Rfc3161) MarshalBinary 

func (m *Rfc3161) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Rfc3161) MarshalJSON 

func (m Rfc3161) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Rfc3161) SetKind 

func (m *Rfc3161) SetKind(val string)

SetKind sets the kind of this subtype

func (*Rfc3161) UnmarshalBinary 

func (m *Rfc3161) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Rfc3161) UnmarshalJSON 

func (m *Rfc3161) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Rfc3161) Validate 

func (m *Rfc3161) Validate(formats strfmt.Registry) error

Validate validates this rfc3161

type Rfc3161Schema 

type Rfc3161Schema interface{}

Rfc3161Schema Timestamp Schema

Schema for RFC 3161 timestamp objects RFC 3161 timestamp objects" aria-label="Go to Schema for RFC 3161 timestamp objects">¶

swagger:model rfc3161Schema

type Rfc3161V001Schema 

type Rfc3161V001Schema struct {

	// tsr
	// Required: true
	Tsr *Rfc3161V001SchemaTsr `json:"tsr"`
}

Rfc3161V001Schema Timestamp v0.0.1 Schema

Schema for RFC3161 entries

swagger:model rfc3161V001Schema

func (*Rfc3161V001Schema) ContextValidate 

func (m *Rfc3161V001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rfc3161 v001 schema based on the context it is used

func (*Rfc3161V001Schema) MarshalBinary 

func (m *Rfc3161V001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Rfc3161V001Schema) UnmarshalBinary 

func (m *Rfc3161V001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Rfc3161V001Schema) Validate 

func (m *Rfc3161V001Schema) Validate(formats strfmt.Registry) error

Validate validates this rfc3161 v001 schema

type Rfc3161V001SchemaTsr 

type Rfc3161V001SchemaTsr struct {

	// Specifies the tsr file content inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

Rfc3161V001SchemaTsr Information about the tsr file associated with the entry

swagger:model Rfc3161V001SchemaTsr

func (*Rfc3161V001SchemaTsr) ContextValidate 

func (m *Rfc3161V001SchemaTsr) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this rfc3161 v001 schema tsr based on context it is used

func (*Rfc3161V001SchemaTsr) MarshalBinary 

func (m *Rfc3161V001SchemaTsr) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Rfc3161V001SchemaTsr) UnmarshalBinary 

func (m *Rfc3161V001SchemaTsr) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Rfc3161V001SchemaTsr) Validate 

func (m *Rfc3161V001SchemaTsr) Validate(formats strfmt.Registry) error

Validate validates this rfc3161 v001 schema tsr

type Rpm 

type Rpm struct {

	// api version
	// Required: true
	// Pattern: ^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$
	APIVersion *string `json:"apiVersion"`

	// spec
	// Required: true
	Spec RpmSchema `json:"spec"`
}

Rpm RPM package

swagger:model rpm

func (*Rpm) ContextValidate 

func (m *Rpm) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rpm based on the context it is used

func (*Rpm) Kind 

func (m *Rpm) Kind() string

Kind gets the kind of this subtype

func (*Rpm) MarshalBinary 

func (m *Rpm) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (Rpm) MarshalJSON 

func (m Rpm) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*Rpm) SetKind 

func (m *Rpm) SetKind(val string)

SetKind sets the kind of this subtype

func (*Rpm) UnmarshalBinary 

func (m *Rpm) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Rpm) UnmarshalJSON 

func (m *Rpm) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*Rpm) Validate 

func (m *Rpm) Validate(formats strfmt.Registry) error

Validate validates this rpm

type RpmSchema 

type RpmSchema interface{}

RpmSchema RPM Schema

Schema for RPM objects

swagger:model rpmSchema

type RpmV001Schema 

type RpmV001Schema struct {

	// package
	// Required: true
	Package *RpmV001SchemaPackage `json:"package"`

	// public key
	// Required: true
	PublicKey *RpmV001SchemaPublicKey `json:"publicKey"`
}

RpmV001Schema RPM v0.0.1 Schema

Schema for RPM entries

swagger:model rpmV001Schema

func (*RpmV001Schema) ContextValidate 

func (m *RpmV001Schema) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rpm v001 schema based on the context it is used

func (*RpmV001Schema) MarshalBinary 

func (m *RpmV001Schema) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RpmV001Schema) UnmarshalBinary 

func (m *RpmV001Schema) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RpmV001Schema) Validate 

func (m *RpmV001Schema) Validate(formats strfmt.Registry) error

Validate validates this rpm v001 schema

type RpmV001SchemaPackage 

type RpmV001SchemaPackage struct {

	// Specifies the package inline within the document
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// hash
	Hash *RpmV001SchemaPackageHash `json:"hash,omitempty"`

	// Values of the RPM headers
	// Read Only: true
	Headers map[string]string `json:"headers,omitempty"`
}

RpmV001SchemaPackage Information about the package associated with the entry

swagger:model RpmV001SchemaPackage

func (*RpmV001SchemaPackage) ContextValidate 

func (m *RpmV001SchemaPackage) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this rpm v001 schema package based on the context it is used

func (*RpmV001SchemaPackage) MarshalBinary 

func (m *RpmV001SchemaPackage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RpmV001SchemaPackage) UnmarshalBinary 

func (m *RpmV001SchemaPackage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RpmV001SchemaPackage) Validate 

func (m *RpmV001SchemaPackage) Validate(formats strfmt.Registry) error

Validate validates this rpm v001 schema package

type RpmV001SchemaPackageHash 

type RpmV001SchemaPackageHash struct {

	// The hashing function used to compute the hash value
	// Required: true
	// Enum: ["sha256"]
	Algorithm *string `json:"algorithm"`

	// The hash value for the package
	// Required: true
	Value *string `json:"value"`
}

RpmV001SchemaPackageHash Specifies the hash algorithm and value for the package

swagger:model RpmV001SchemaPackageHash

func (*RpmV001SchemaPackageHash) ContextValidate 

func (m *RpmV001SchemaPackageHash) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this rpm v001 schema package hash based on context it is used

func (*RpmV001SchemaPackageHash) MarshalBinary 

func (m *RpmV001SchemaPackageHash) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RpmV001SchemaPackageHash) UnmarshalBinary 

func (m *RpmV001SchemaPackageHash) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RpmV001SchemaPackageHash) Validate 

func (m *RpmV001SchemaPackageHash) Validate(formats strfmt.Registry) error

Validate validates this rpm v001 schema package hash

type RpmV001SchemaPublicKey 

type RpmV001SchemaPublicKey struct {

	// Specifies the content of the public key inline within the document
	// Required: true
	// Format: byte
	Content *strfmt.Base64 `json:"content"`
}

RpmV001SchemaPublicKey The PGP public key that can verify the RPM signature

swagger:model RpmV001SchemaPublicKey

func (*RpmV001SchemaPublicKey) ContextValidate 

func (m *RpmV001SchemaPublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this rpm v001 schema public key based on context it is used

func (*RpmV001SchemaPublicKey) MarshalBinary 

func (m *RpmV001SchemaPublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RpmV001SchemaPublicKey) UnmarshalBinary 

func (m *RpmV001SchemaPublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RpmV001SchemaPublicKey) Validate 

func (m *RpmV001SchemaPublicKey) Validate(formats strfmt.Registry) error

Validate validates this rpm v001 schema public key

type SearchIndex 

type SearchIndex struct {

	// email
	// Format: email
	Email strfmt.Email `json:"email,omitempty"`

	ParticipantID string `json:"participantid,omitempty"`

	// hash
	// Pattern: ^(sha512:)?[0-9a-fA-F]{128}$|^(sha256:)?[0-9a-fA-F]{64}$|^(sha1:)?[0-9a-fA-F]{40}$
	Hash string `json:"hash,omitempty"`

	// operator
	// Enum: ["and","or"]
	Operator string `json:"operator,omitempty"`

	// public key
	PublicKey *SearchIndexPublicKey `json:"publicKey,omitempty"`
}

SearchIndex search index

swagger:model SearchIndex

func (*SearchIndex) ContextValidate 

func (m *SearchIndex) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this search index based on the context it is used

func (*SearchIndex) MarshalBinary 

func (m *SearchIndex) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SearchIndex) UnmarshalBinary 

func (m *SearchIndex) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SearchIndex) Validate 

func (m *SearchIndex) Validate(formats strfmt.Registry) error

Validate validates this search index

type SearchIndexPublicKey 

type SearchIndexPublicKey struct {

	// content
	// Format: byte
	Content strfmt.Base64 `json:"content,omitempty"`

	// format
	// Required: true
	// Enum: ["pgp","x509","minisign","ssh","tuf"]
	Format *string `json:"format"`

	// url
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

SearchIndexPublicKey search index public key

swagger:model SearchIndexPublicKey

func (*SearchIndexPublicKey) ContextValidate 

func (m *SearchIndexPublicKey) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validates this search index public key based on context it is used

func (*SearchIndexPublicKey) MarshalBinary 

func (m *SearchIndexPublicKey) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SearchIndexPublicKey) UnmarshalBinary 

func (m *SearchIndexPublicKey) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SearchIndexPublicKey) Validate 

func (m *SearchIndexPublicKey) Validate(formats strfmt.Registry) error

Validate validates this search index public key

type SearchLogQuery 

type SearchLogQuery struct {

	// entry u UI ds
	// Max Items: 50
	// Min Items: 1
	EntryUUIDs []string `json:"entryUUIDs"`

	// log indexes
	// Max Items: 10000
	// Min Items: 1
	LogIndexes []*int64 `json:"logIndexes"`
	// contains filtered or unexported fields
}

SearchLogQuery search log query

swagger:model SearchLogQuery

func (*SearchLogQuery) ContextValidate 

func (m *SearchLogQuery) ContextValidate(ctx context.Context, formats strfmt.Registry) error

ContextValidate validate this search log query based on the context it is used

func (*SearchLogQuery) Entries 

func (m *SearchLogQuery) Entries() []ProposedEntry

Entries gets the entries of this base type

func (*SearchLogQuery) MarshalBinary 

func (m *SearchLogQuery) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (SearchLogQuery) MarshalJSON 

func (m SearchLogQuery) MarshalJSON() ([]byte, error)

MarshalJSON marshals this object with a polymorphic type to a JSON structure

func (*SearchLogQuery) SetEntries 

func (m *SearchLogQuery) SetEntries(val []ProposedEntry)

SetEntries sets the entries of this base type

func (*SearchLogQuery) UnmarshalBinary 

func (m *SearchLogQuery) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SearchLogQuery) UnmarshalJSON 

func (m *SearchLogQuery) UnmarshalJSON(raw []byte) error

UnmarshalJSON unmarshals this object with a polymorphic type from a JSON structure

func (*SearchLogQuery) Validate 

func (m *SearchLogQuery) Validate(formats strfmt.Registry) error

Validate validates this search log query

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.