Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
31 kB · 925 lines
Go
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926// Code generated from JSON Schema using quicktype. DO NOT EDIT.// To parse and unparse this JSON data, add this code to your project and do://// c2Patypes, err := UnmarshalC2Patypes(bytes)// bytes, err = c2Patypes.Marshal()
package c2patypes
import "bytes"import "errors"
import "encoding/json"
func UnmarshalC2Patypes(data []byte) (C2Patypes, error) { var r C2Patypes err := json.Unmarshal(data, &r) return r, err}
func (r *C2Patypes) Marshal() ([]byte, error) { return json.Marshal(r)}
type C2Patypes struct { Builder Builder `json:"builder"` ManifestDefinition ManifestDefinition `json:"manifest_definition"` Reader Reader `json:"reader"`}
// Use a Builder to add a signed manifest to an asset.//// # Example: Building and signing a manifest//// ``` use c2pa::Result; use std::path::PathBuf;//// use c2pa::{create_signer, Builder, SigningAlg}; use serde::Serialize; use// serde_json::json; use tempfile::tempdir;//// #[derive(Serialize)] struct Test { my_tag: usize, }//// # fn main() -> Result<()> { #[cfg(feature = "file_io")] { let manifest_json = json!({// "claim_generator_info": [ { "name": "c2pa_test", "version": "1.0.0" } ], "title":// "Test_Manifest" }).to_string();//// let mut builder = Builder::from_json(&manifest_json)?;// builder.add_assertion("org.contentauth.test", &Test { my_tag: 42 })?;//// let source = PathBuf::from("tests/fixtures/C.jpg"); let dir = tempdir()?; let dest =// dir.path().join("test_file.jpg");//// // Create a ps256 signer using certs and key files. TO DO: Update example. let// signcert_path = "tests/fixtures/certs/ps256.pub"; let pkey_path =// "tests/fixtures/certs/ps256.pem"; let signer = create_signer::from_files(signcert_path,// pkey_path, SigningAlg::Ps256, None)?;//// // embed a manifest using the signer builder.sign_file( signer.as_ref(), &source,// &dest)?; } # Ok(()) # } ```type Builder struct { // A list of assertions Assertions []AssertionDefinition `json:"assertions,omitempty"` // Base path to search for resources. BasePath *string `json:"base_path"` // The type of builder being used. BuilderFlow *BuilderFlowUnion `json:"builder_flow"` // Claim Generator Info is always required with at least one entry ClaimGeneratorInfo []ClaimGeneratorInfo `json:"claim_generator_info,omitempty"` // The version of the claim. Defaults to 1. ClaimVersion *int64 `json:"claim_version"` // The format of the source file as a MIME type. Format *string `json:"format,omitempty"` // A List of ingredients Ingredients []Ingredient `json:"ingredients,omitempty"` // Instance ID from `xmpMM:InstanceID` in XMP metadata. InstanceID *string `json:"instance_id,omitempty"` // Allows you to pre-define the manifest label, which must be unique. Not intended for // general use. If not set, it will be assigned automatically. Label *string `json:"label"` // Optional manifest metadata. This will be deprecated in the future; not recommended to use. Metadata []AssertionMetadata `json:"metadata"` // If true, the manifest store will not be embedded in the asset on sign NoEmbed bool `json:"no_embed"` // A list of redactions - URIs to redacted assertions. Redactions []string `json:"redactions"` // Optional remote URL for the manifest RemoteURL *string `json:"remote_url"` // An optional ResourceRef to a thumbnail image that represents the asset that was signed. // Must be available when the manifest is signed. Thumbnail *IngredientResourceRef `json:"thumbnail"` // A human-readable title, generally source filename. Title *string `json:"title"` // Optional prefix added to the generated Manifest Label This is typically a reverse domain // name. Vendor *string `json:"vendor"`}
// Defines an assertion that consists of a label that can be either a C2PA-defined assertion// label or a custom label in reverse domain format.type AssertionDefinition struct { Data interface{} `json:"data"` Label string `json:"label"`}
type BuilderFlowClass struct { Create DigitalSourceType `json:"Create"`}
// Description of the claim generator, or the software used in generating the claim.//// This structure is also used for actions softwareAgenttype ClaimGeneratorInfo struct { // hashed URI to the icon (either embedded or remote) Icon *ResourceRef `json:"icon"` // A human readable string naming the claim_generator Name string `json:"name"` // A human readable string of the OS the claim generator is running on OperatingSystem *string `json:"operating_system"` // A human readable string of the product's version Version *string `json:"version"`}
// A reference to a resource to be used in JSON serialization.//// The underlying data can be read as a stream via// [`Reader::resource_to_stream`][crate::Reader::resource_to_stream].//// A `HashedUri` provides a reference to content available within the same manifest store.//// This is described in [§8.3, URI References], of the C2PA Technical Specification.//// [§8.3, URI References]:// https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_uri_referencestype ResourceRef struct { // The algorithm used to hash the resource (if applicable). // // A string identifying the cryptographic hash algorithm used to compute the hash Alg *string `json:"alg"` // More detailed data types as defined in the C2PA spec. DataTypes []AssetType `json:"data_types"` // The mime type of the referenced resource. Format *string `json:"format,omitempty"` // The hash of the resource (if applicable). // // Byte string containing the hash value Hash *BasePath `json:"hash"` // A URI that identifies the resource as referenced from the manifest. // // This may be a JUMBF URI, a file path, a URL or any other string. Relative JUMBF URIs will // be resolved with the manifest label. Relative file paths will be resolved with the base // path if provided. Identifier *string `json:"identifier,omitempty"` // JUMBF URI reference URL *string `json:"url,omitempty"`}
type AssetType struct { Type string `json:"type"` Version *string `json:"version"`}
// An `Ingredient` is any external asset that has been used in the creation of an asset.type Ingredient struct { // The active manifest label (if one exists). // // If this ingredient has a [`ManifestStore`], this will hold the label of the active // [`Manifest`]. // // [`Manifest`]: crate::Manifest [`ManifestStore`]: crate::ManifestStore ActiveManifest *string `json:"active_manifest"` // A reference to the actual data of the ingredient. Data *IngredientResourceRef `json:"data"` // Additional information about the data's type to the ingredient V2 structure. DataTypes []AssetType `json:"data_types"` // Additional description of the ingredient. Description *string `json:"description"` // Document ID from `xmpMM:DocumentID` in XMP metadata. DocumentID *string `json:"document_id"` // The format of the source file as a MIME type. Format *string `json:"format"` // An optional hash of the asset to prevent duplicates. Hash *string `json:"hash"` // URI to an informational page about the ingredient or its data. InformationalURI *string `json:"informational_URI"` // Instance ID from `xmpMM:InstanceID` in XMP metadata. InstanceID *string `json:"instance_id"` // The ingredient's label as assigned in the manifest. Label *string `json:"label"` // A [`ManifestStore`] from the source asset extracted as a binary C2PA blob. // // [`ManifestStore`]: crate::ManifestStore ManifestData *IngredientResourceRef `json:"manifest_data"` // Any additional [`Metadata`] as defined in the C2PA spec. // // [`Metadata`]: crate::Metadata Metadata *AssertionMetadata `json:"metadata"` // URI from `dcterms:provenance` in XMP metadata. Provenance *string `json:"provenance"` // Set to `ParentOf` if this is the parent ingredient. // // There can only be one parent ingredient in the ingredients. Relationship *Relationship `json:"relationship,omitempty"` Resources *ResourceStore `json:"resources,omitempty"` // A thumbnail image capturing the visual state at the time of import. // // A tuple of thumbnail MIME format (for example `image/jpeg`) and binary bits of the image. Thumbnail *IngredientResourceRef `json:"thumbnail"` // A human-readable title, generally source filename. Title *string `json:"title"` // Validation results (Ingredient.V3) ValidationResults *ValidationResults `json:"validation_results"` // Validation status (Ingredient v1 & v2) ValidationStatus []ValidationStatus `json:"validation_status"`}
// A reference to a resource to be used in JSON serialization.//// The underlying data can be read as a stream via// [`Reader::resource_to_stream`][crate::Reader::resource_to_stream].type IngredientResourceRef struct { // The algorithm used to hash the resource (if applicable). Alg *string `json:"alg"` // More detailed data types as defined in the C2PA spec. DataTypes []AssetType `json:"data_types"` // The mime type of the referenced resource. Format string `json:"format"` // The hash of the resource (if applicable). Hash *string `json:"hash"` // A URI that identifies the resource as referenced from the manifest. // // This may be a JUMBF URI, a file path, a URL or any other string. Relative JUMBF URIs will // be resolved with the manifest label. Relative file paths will be resolved with the base // path if provided. Identifier string `json:"identifier"`}
// A region of interest within an asset describing the change.//// This struct can be used from [`Action::changes`][crate::assertions::Action::changes] or// [`AssertionMetadata::region_of_interest`][crate::assertions::AssertionMetadata::region_of_interest].type RegionOfInterest struct { // A free-text string. Description *string `json:"description"` // A free-text string representing a machine-readable, unique to this assertion, identifier // for the region. Identifier *string `json:"identifier"` // Additional information about the asset. Metadata *AssertionMetadata `json:"metadata"` // A free-text string representing a human-readable name for the region which might be used // in a user interface. Name *string `json:"name"` // A range describing the region of interest for the specific asset. Region []Range `json:"region"` // A value from our controlled vocabulary or an entity-specific value (e.g., // com.litware.coolArea) that represents the role of a region among other regions. Role *Role `json:"role"` // A value from a controlled vocabulary such as // <https://cv.iptc.org/newscodes/imageregiontype/> or an entity-specific value (e.g., // com.litware.newType) that represents the type of thing(s) depicted by a region. // // Note this field serializes/deserializes into the name `type`. Type *string `json:"type"`}
// The AssertionMetadata structure can be used as part of other assertions or on its own to// reference otherstype AssertionMetadata struct { DataSource *DataSource `json:"dataSource"` DateTime *string `json:"dateTime"` Reference *HashedURI `json:"reference"` RegionOfInterest *RegionOfInterest `json:"regionOfInterest"` ReviewRatings []ReviewRating `json:"reviewRatings"`}
// A spatial, temporal, frame, or textual range describing the region of interest.type Range struct { // A frame range. Frame *Frame `json:"frame"` // A item identifier. Item *Item `json:"item"` // A spatial range. Shape *Shape `json:"shape"` // A textual range. Text *Text `json:"text"` // A temporal range. Time *Time `json:"time"` // The type of range of interest. Type RangeType `json:"type"`}
// A frame range representing starting and ending frames or pages.//// If both `start` and `end` are missing, the frame will span the entire asset.type Frame struct { // The end of the frame inclusive or the end of the asset if not present. End *int64 `json:"end"` // The start of the frame or the end of the asset if not present. // // The first frame/page starts at 0. Start *int64 `json:"start"`}
// Description of the boundaries of an identified range.type Item struct { // The container-specific term used to identify items, such as "track_id" for MP4 or // "item_ID" for HEIF. Identifier string `json:"identifier"` // The value of the identifier, e.g. a value of "2" for an identifier of "track_id" would // imply track 2 of the asset. Value string `json:"value"`}
// A spatial range representing rectangle, circle, or a polygon.type Shape struct { // The height of a rectnagle. // // This field can be ignored for circles and polygons. Height *float64 `json:"height"` // If the range is inside the shape. // // The default value is true. Inside *bool `json:"inside"` // THe origin of the coordinate in the shape. Origin Coordinate `json:"origin"` // The type of shape. Type ShapeType `json:"type"` // The type of unit for the shape range. Unit UnitType `json:"unit"` // The vertices of the polygon. // // This field can be ignored for rectangles and circles. Vertices []Coordinate `json:"vertices"` // The width for rectangles or diameter for circles. // // This field can be ignored for polygons. Width *float64 `json:"width"`}
// THe origin of the coordinate in the shape.//// An x, y coordinate used for specifying vertices in polygons.type Coordinate struct { // The coordinate along the x-axis. X float64 `json:"x"` // The coordinate along the y-axis. Y float64 `json:"y"`}
// A textual range representing multiple (possibly discontinuous) ranges of text.type Text struct { // The ranges of text to select. Selectors []TextSelectorRange `json:"selectors"`}
// One or two [`TextSelector`][TextSelector] identifiying the range to select.type TextSelectorRange struct { // The end of the text range. End *TextSelector `json:"end"` // The start (or entire) text range. Selector TextSelector `json:"selector"`}
// Selects a range of text via a fragment identifier.//// This is modeled after the W3C Web Annotation selector model.//// The start (or entire) text range.type TextSelector struct { // The end character offset or the end of the fragment if not present. End *int64 `json:"end"` // Fragment identifier as per RFC3023 (XML) or ISO 32000-2 (PDF), Annex O. Fragment string `json:"fragment"` // The start character offset or the start of the fragment if not present. Start *int64 `json:"start"`}
// A temporal range representing a starting time to an ending time.type Time struct { // The end time or the end of the asset if not present. End *string `json:"end"` // The start time or the start of the asset if not present. Start *string `json:"start"` // The type of time. Type *TimeType `json:"type,omitempty"`}
// A description of the source for assertion datatype DataSource struct { // A list of [`Actor`]s associated with this source. Actors []Actor `json:"actors"` // A human-readable string giving details about the source of the assertion data. Details *string `json:"details"` // A value from among the enumerated list indicating the source of the assertion. Type string `json:"type"`}
// Identifies a person responsible for an action.type Actor struct { // List of references to W3C Verifiable Credentials. Credentials []HashedURI `json:"credentials"` // An identifier for a human actor, used when the "type" is `humanEntry.identified`. Identifier *string `json:"identifier"`}
// A `HashedUri` provides a reference to content available within the same manifest store.//// This is described in [§8.3, URI References], of the C2PA Technical Specification.//// [§8.3, URI References]:// https://c2pa.org/specifications/specifications/2.1/specs/C2PA_Specification.html#_uri_referencestype HashedURI struct { // A string identifying the cryptographic hash algorithm used to compute the hash Alg *string `json:"alg"` // Byte string containing the hash value Hash []int64 `json:"hash"` // JUMBF URI reference URL string `json:"url"`}
// A rating on an Assertion.//// See// <https://c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_review_ratings>.type ReviewRating struct { Code *string `json:"code"` Explanation string `json:"explanation"` Value int64 `json:"value"`}
// Resource store to contain binary objects referenced from JSON serializable structures//// container for binary assets (like thumbnails)type ResourceStore struct { BasePath *string `json:"base_path"` Label *string `json:"label"` Resources map[string][]int64 `json:"resources"`}
// A map of validation results for a manifest store.//// The map contains the validation results for the active manifest and any ingredient// deltas. It is normal for there to be manytype ValidationResults struct { ActiveManifest *StatusCodes `json:"activeManifest"` IngredientDeltas []IngredientDeltaValidationResult `json:"ingredientDeltas"`}
// Contains a set of success, informational, and failure validation status codes.//// Validation results for the ingredient's active manifesttype StatusCodes struct { Failure []ValidationStatus `json:"failure"` Informational []ValidationStatus `json:"informational"` Success []ValidationStatus `json:"success"`}
// A `ValidationStatus` struct describes the validation status of a specific part of a// manifest.//// See// <https://c2pa.org/specifications/specifications/2.2/specs/C2PA_Specification.html#_existing_manifests>.type ValidationStatus struct { Code string `json:"code"` Explanation *string `json:"explanation"` Success *bool `json:"success"` URL *string `json:"url"`}
// Represents any changes or deltas between the current and previous validation results for// an ingredient's manifest.type IngredientDeltaValidationResult struct { // JUMBF URI reference to the ingredient assertion IngredientAssertionURI string `json:"ingredientAssertionURI"` // Validation results for the ingredient's active manifest ValidationDeltas StatusCodes `json:"validationDeltas"`}
// Use a ManifestDefinition to define a manifest and to build a `ManifestStore`. A manifest// is a collection of ingredients and assertions used to define a claim that can be signed// and embedded into a file.type ManifestDefinition struct { // A list of assertions Assertions []AssertionDefinition `json:"assertions,omitempty"` // Claim Generator Info is always required with at least one entry ClaimGeneratorInfo []ClaimGeneratorInfo `json:"claim_generator_info,omitempty"` // The version of the claim. Defaults to 1. ClaimVersion *int64 `json:"claim_version"` // The format of the source file as a MIME type. Format *string `json:"format,omitempty"` // A List of ingredients Ingredients []Ingredient `json:"ingredients,omitempty"` // Instance ID from `xmpMM:InstanceID` in XMP metadata. InstanceID *string `json:"instance_id,omitempty"` // Allows you to pre-define the manifest label, which must be unique. Not intended for // general use. If not set, it will be assigned automatically. Label *string `json:"label"` // Optional manifest metadata. This will be deprecated in the future; not recommended to use. Metadata []AssertionMetadata `json:"metadata"` // A list of redactions - URIs to redacted assertions. Redactions []string `json:"redactions"` // An optional ResourceRef to a thumbnail image that represents the asset that was signed. // Must be available when the manifest is signed. Thumbnail *IngredientResourceRef `json:"thumbnail"` // A human-readable title, generally source filename. Title *string `json:"title"` // Optional prefix added to the generated Manifest Label This is typically a reverse domain // name. Vendor *string `json:"vendor"`}
// Use a Reader to read and validate a manifest store.type Reader struct { // A label for the active (most recent) manifest in the store ActiveManifest *string `json:"active_manifest"` // A HashMap of Manifests Manifests map[string]Manifest `json:"manifests"` // ValidationStatus generated when loading the ManifestStore from an asset ValidationResults *ValidationResults `json:"validation_results"` // The validation state of the manifest store ValidationState *ValidationState `json:"validation_state"` // ValidationStatus generated when loading the ManifestStore from an asset ValidationStatus []ValidationStatus `json:"validation_status"`}
// A Manifest represents all the information in a c2pa manifesttype Manifest struct { // A list of assertions Assertions []ManifestAssertion `json:"assertions,omitempty"` // A User Agent formatted string identifying the software/hardware/system produced this // claim Spaces are not allowed in names, versions can be specified with product/1.0 syntax. ClaimGenerator *string `json:"claim_generator"` // A list of claim generator info data identifying the software/hardware/system produced // this claim. ClaimGeneratorInfo []ClaimGeneratorInfo `json:"claim_generator_info"` // A List of verified credentials Credentials []interface{} `json:"credentials"` // The format of the source file as a MIME type. Format *string `json:"format"` // A List of ingredients Ingredients []Ingredient `json:"ingredients,omitempty"` // Instance ID from `xmpMM:InstanceID` in XMP metadata. InstanceID *string `json:"instance_id,omitempty"` Label *string `json:"label"` // A list of user metadata for this claim. Metadata []AssertionMetadata `json:"metadata"` // A list of redactions - URIs to a redacted assertions Redactions []string `json:"redactions"` // container for binary assets (like thumbnails) Resources *ResourceStore `json:"resources,omitempty"` // Signature data (only used for reporting) SignatureInfo *SignatureInfo `json:"signature_info"` Thumbnail *IngredientResourceRef `json:"thumbnail"` // A human-readable title, generally source filename. Title *string `json:"title"` // Optional prefix added to the generated Manifest label. This is typically an internet // domain name for the vendor (i.e. `adobe`). Vendor *string `json:"vendor"`}
// A labeled container for an Assertion value in a Manifesttype ManifestAssertion struct { // The data of the assertion as Value Data interface{} `json:"data"` // There can be more than one assertion for any label Instance *int64 `json:"instance"` // The [ManifestAssertionKind] for this assertion (as stored in c2pa content) Kind *ManifestAssertionKind `json:"kind"` // An assertion label in reverse domain format Label string `json:"label"`}
// Holds information about a signaturetype SignatureInfo struct { // Human-readable issuing authority for this signature. Alg *SigningAlg `json:"alg"` // The serial number of the certificate. CERTSerialNumber *string `json:"cert_serial_number"` // Human-readable issuing authority for this signature. Issuer *string `json:"issuer"` // Revocation status of the certificate. RevocationStatus *bool `json:"revocation_status"` // The time the signature was created. Time *string `json:"time"`}
// Media whose digital content is effectively empty, such as a blank canvas or zero-length// video.//// Data that is the result of algorithmically using a model derived from sampled content and// data. Differs from// <http://cv.iptc.org/newscodes/digitalsourcetype/>trainedAlgorithmicMedia in that the// result isn’t a media type (e.g., image or video) but is a data format (e.g., CSV, pickle).type DigitalSourceType string
const ( Empty DigitalSourceType = "Empty" TrainedAlgorithmicData DigitalSourceType = "TrainedAlgorithmicData")
type BuilderFlowEnum string
const ( Open BuilderFlowEnum = "Open" Update BuilderFlowEnum = "Update")
// The type of shape.//// The type of shape for the range.//// A rectangle.//// A circle.//// A polygon.type ShapeType string
const ( Circle ShapeType = "circle" Polygon ShapeType = "polygon" Rectangle ShapeType = "rectangle")
// The type of unit for the shape range.//// The type of unit for the range.//// Use pixels.//// Use percentage.type UnitType string
const ( Percent UnitType = "percent" Pixel UnitType = "pixel")
// The type of time.//// Times are described using Normal Play Time (npt) as described in RFC 2326.type TimeType string
const ( Npt TimeType = "npt")
// The type of range of interest.//// The type of range for the region of interest.//// A spatial range, see [`Shape`] for more details.//// A temporal range, see [`Time`] for more details.//// A spatial range, see [`Frame`] for more details.//// A textual range, see [`Text`] for more details.//// A range identified by a specific identifier and value, see [`Item`] for more details.type RangeType string
const ( Identified RangeType = "identified" RangeTypeFrame RangeType = "frame" Spatial RangeType = "spatial" Temporal RangeType = "temporal" Textual RangeType = "textual")
// Arbitrary area worth identifying.//// This area is all that is left after a crop action.//// This area has had edits applied to it.//// The area where an ingredient was placed/added.//// Something in this area was redacted.//// Area specific to a subject (human or not).//// A range of information was removed/deleted.//// Styling was applied to this area.//// Invisible watermarking was applied to this area for the purpose of soft binding.type Role string
const ( C2PaAreaOfInterest Role = "c2pa.areaOfInterest" C2PaCropped Role = "c2pa.cropped" C2PaDeleted Role = "c2pa.deleted" C2PaEdited Role = "c2pa.edited" C2PaPlaced Role = "c2pa.placed" C2PaRedacted Role = "c2pa.redacted" C2PaStyled Role = "c2pa.styled" C2PaSubjectArea Role = "c2pa.subjectArea" C2PaWatermarked Role = "c2pa.watermarked")
// Set to `ParentOf` if this is the parent ingredient.//// There can only be one parent ingredient in the ingredients.//// The relationship of the ingredient to the current asset.//// The current asset is derived from this ingredient.//// The current asset is a part of this ingredient.//// The ingredient was used as an input to a computational process to create or modify the// asset.type Relationship string
const ( ComponentOf Relationship = "componentOf" InputTo Relationship = "inputTo" ParentOf Relationship = "parentOf")
// Assertions in C2PA can be stored in several formatstype ManifestAssertionKind string
const ( Binary ManifestAssertionKind = "Binary" Cbor ManifestAssertionKind = "Cbor" JSON ManifestAssertionKind = "Json" URI ManifestAssertionKind = "Uri")
// ECDSA with SHA-256//// # ECDSA with SHA-256 on secp256k1 curve//// # ECDSA with SHA-384//// # ECDSA with SHA-512//// # RSASSA-PSS using SHA-256 and MGF1 with SHA-256//// # RSASSA-PSS using SHA-384 and MGF1 with SHA-384//// # RSASSA-PSS using SHA-512 and MGF1 with SHA-512//// Edwards-Curve DSA (Ed25519 instance only)type SigningAlg string
const ( Ed25519 SigningAlg = "Ed25519" Es256 SigningAlg = "Es256" Es256K SigningAlg = "Es256K" Es384 SigningAlg = "Es384" Es512 SigningAlg = "Es512" Ps256 SigningAlg = "Ps256" Ps384 SigningAlg = "Ps384" Ps512 SigningAlg = "Ps512")
// Errors were found in the manifest store.//// No errors were found in validation, but the active signature is not trusted.//// The manifest store is valid and the active signature is trusted.type ValidationState string
const ( Invalid ValidationState = "Invalid" Trusted ValidationState = "Trusted" Valid ValidationState = "Valid")
// The type of builder being used.type BuilderFlowUnion struct { BuilderFlowClass *BuilderFlowClass Enum *BuilderFlowEnum}
func (x *BuilderFlowUnion) UnmarshalJSON(data []byte) error { x.BuilderFlowClass = nil x.Enum = nil var c BuilderFlowClass object, err := unmarshalUnion(data, nil, nil, nil, nil, false, nil, true, &c, false, nil, true, &x.Enum, true) if err != nil { return err } if object { x.BuilderFlowClass = &c } return nil}
func (x *BuilderFlowUnion) MarshalJSON() ([]byte, error) { return marshalUnion(nil, nil, nil, nil, false, nil, x.BuilderFlowClass != nil, x.BuilderFlowClass, false, nil, x.Enum != nil, x.Enum, true)}
type BasePath struct { IntegerArray []int64 String *string}
func (x *BasePath) UnmarshalJSON(data []byte) error { x.IntegerArray = nil object, err := unmarshalUnion(data, nil, nil, nil, &x.String, true, &x.IntegerArray, false, nil, false, nil, false, nil, true) if err != nil { return err } if object { } return nil}
func (x *BasePath) MarshalJSON() ([]byte, error) { return marshalUnion(nil, nil, nil, x.String, x.IntegerArray != nil, x.IntegerArray, false, nil, false, nil, false, nil, true)}
func unmarshalUnion(data []byte, pi **int64, pf **float64, pb **bool, ps **string, haveArray bool, pa interface{}, haveObject bool, pc interface{}, haveMap bool, pm interface{}, haveEnum bool, pe interface{}, nullable bool) (bool, error) { if pi != nil { *pi = nil } if pf != nil { *pf = nil } if pb != nil { *pb = nil } if ps != nil { *ps = nil }
dec := json.NewDecoder(bytes.NewReader(data)) dec.UseNumber() tok, err := dec.Token() if err != nil { return false, err }
switch v := tok.(type) { case json.Number: if pi != nil { i, err := v.Int64() if err == nil { *pi = &i return false, nil } } if pf != nil { f, err := v.Float64() if err == nil { *pf = &f return false, nil } return false, errors.New("Unparsable number") } return false, errors.New("Union does not contain number") case float64: return false, errors.New("Decoder should not return float64") case bool: if pb != nil { *pb = &v return false, nil } return false, errors.New("Union does not contain bool") case string: if haveEnum { return false, json.Unmarshal(data, pe) } if ps != nil { *ps = &v return false, nil } return false, errors.New("Union does not contain string") case nil: if nullable { return false, nil } return false, errors.New("Union does not contain null") case json.Delim: if v == '{' { if haveObject { return true, json.Unmarshal(data, pc) } if haveMap { return false, json.Unmarshal(data, pm) } return false, errors.New("Union does not contain object") } if v == '[' { if haveArray { return false, json.Unmarshal(data, pa) } return false, errors.New("Union does not contain array") } return false, errors.New("Cannot handle delimiter") } return false, errors.New("Cannot unmarshal union")}
func marshalUnion(pi *int64, pf *float64, pb *bool, ps *string, haveArray bool, pa interface{}, haveObject bool, pc interface{}, haveMap bool, pm interface{}, haveEnum bool, pe interface{}, nullable bool) ([]byte, error) { if pi != nil { return json.Marshal(*pi) } if pf != nil { return json.Marshal(*pf) } if pb != nil { return json.Marshal(*pb) } if ps != nil { return json.Marshal(*ps) } if haveArray { return json.Marshal(pa) } if haveObject { return json.Marshal(pc) } if haveMap { return json.Marshal(pm) } if haveEnum { return json.Marshal(pe) } if nullable { return json.Marshal(nil) } return nil, errors.New("Union must not be null")}