acorn-schema 0.4.0

//! ## Research activity identifier (RAiD) metadata schema
//!
//! See <https://metadata.raid.org/en/v1.6/index.html> for official documentation on reference schema.
//!
//! Use ACORN to generate JSON schema for RAiD metadata with `acorn schema raid`
use crate::pid::{PersistentIdentifier, PersistentIdentifierConvert, PersistentIdentifierParse};
use crate::util::constants::{RE_DOI, RE_RAID_TEXT};
use crate::validation::{report_of, validate_license, IntoValidationReport, Validate, ValidationReport};
use crate::vocabulary;
use crate::Date;
use crate::OneOrMany;
use acorn_core::prelude::alloc::{format, String, ToString, Vec};
use acorn_core::util::{regex_capture_lookup, trim_unmatched_trailing_parentheses, StringExt};
use acorn_core::validation::ValidationError;
use alloc::collections::BTreeSet;
use bon::Builder;
use core::fmt;
use derive_more::Display;
#[cfg(feature = "std")]
use schemars::schema_for;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use serde_with::skip_serializing_none;
use strum::EnumIs;

/// Allowed values for access types
#[derive(Clone, Debug, Default, Deserialize, Display, JsonSchema, Serialize)]
pub enum AccessType {
    /// Open access
    #[default]
    #[display("open-access")]
    #[serde(rename = "https://vocabularies.coar-repositories.org/access_rights/c_abf2/")]
    OpenAccess,
    /// Embargoed access
    #[display("embargoed-access")]
    #[serde(rename = "https://vocabularies.coar-repositories.org/access_rights/c_f1cf/")]
    EmbargoedAccess,
}
/// CRediT role
///
/// Taxonomy of 14 roles that can be used to describe the key types of contributions typically made to the production and publication of research output such as research articles.
///
/// See <https://www.niso.org/publications/z39104-2022-credit>
#[derive(Clone, Debug, Deserialize, Display, JsonSchema, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum CreditRole {
    /// Ideas; formulation or evolution of overarching research goals and aims.
    #[display("conceptualization")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/conceptualization/")]
    Conceptualization,
    /// Management activities to annotate (produce metadata), scrub data and maintain research data (including software code, where it is necessary for interpreting the data itself) for initial use and later re-use.
    #[display("data-curation")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/data-curation/")]
    DataCuration,
    /// Application of statistical, mathematical, computational, or other formal techniques to analyze or synthesize study data.
    #[display("formal-analysis")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/formal-analysis/")]
    FormalAnalysis,
    /// Acquisition of the financial support for the project leading to this publication.
    #[display("funding-acquisition")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/funding-acquisition/")]
    FundingAcquisition,
    /// Conducting a research and investigation process, specifically performing the experiments, or data/evidence collection.
    #[display("investigation")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/investigation/")]
    Investigation,
    /// Development or design of methodology; creation of models.
    #[display("methodology")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/methodology/")]
    Methodology,
    /// Management and coordination responsibility for the research activity planning and execution.
    #[display("project-administration")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/project-administration/")]
    ProjectAdministration,
    /// Provision of study materials, reagents, materials, patients, laboratory samples, animals, instrumentation, computing resources, or other analysis tools.
    #[display("resources")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/resources/")]
    Resources,
    /// Programming, software development; designing computer programs; implementation of the computer code and supporting algorithms; testing of existing code components.
    #[display("software")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/software/")]
    Software,
    /// Oversight and leadership responsibility for the research activity planning and execution, including mentorship external to the core team.
    #[display("supervision")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/supervision/")]
    Supervision,
    /// Verification, whether as a part of the activity or separate, of the overall replication/reproducibility of results/experiments and other research outputs.
    #[display("validation")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/validation/")]
    Validation,
    /// Preparation, creation and/or presentation of the published work, specifically visualization/data presentation.
    #[display("visualization")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/visualization/")]
    Visualization,
    /// Preparation, creation and/or presentation of the published work, specifically writing the initial draft (including substantive translation).
    #[display("writing-original-draft")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/writing-original-draft/")]
    WritingOriginalDraft,
    /// Preparation, creation and/or presentation of the published work by those from the original research group, specifically critical review, commentary or revision - including pre- or post-publication stages
    #[display("writing-review-editing")]
    #[serde(rename = "https://credit.niso.org/contributor-roles/writing-review-editing/")]
    WritingReviewEditing,
}
/// Description types
#[derive(Clone, Debug, Deserialize, Display, JsonSchema, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum DescriptionType {
    /// Primary description (i.e., a preferred full description or abstract)
    #[display("primary")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/318")]
    Primary,
    /// An alternative description (i.e., an additional or supplementary full description or abstract)
    #[display("alternative")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/319")]
    Alternative,
    /// Brief description (i.e., a shorter version of the primary description)
    #[display("brief")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/3")]
    Brief,
    /// Significance statement
    #[display("significance-statement")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/9")]
    SignificanceStatement,
    /// Methods
    #[display("methods")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/8")]
    Methods,
    /// Objectives
    #[display("objectives")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/7")]
    Objectives,
    /// Acknowledgements (i.e., for recognition of people not listed as Contributors or organizations not listed as organizations)
    #[display("acknowledgements")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/392")]
    Acknowledgements,
    /// Other (i.e., any other descriptive information such as a note)
    #[display("other")]
    #[serde(rename = "https://vocabulary.raid.org/description.type.schema/6")]
    Other,
}
/// Category of input, output, or process document
#[derive(Clone, Debug, Deserialize, Display, JsonSchema, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum ObjectCategoryType {
    /// Output
    #[display("output")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.category.id/190")]
    Output,
    /// Input
    #[display("input")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.category.id/191")]
    Input,
    /// Internal process document or artifact
    #[display("internal-process-document")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.category.id/192")]
    InternalProcessDocument,
}
/// Type of input, output, or process document
#[derive(Clone, Debug, Deserialize, Display, JsonSchema, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum ObjectType {
    /// Output management plan
    #[display("output-management-plan")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/247")]
    OutputManagementPlan,
    /// Conference poster
    #[display("conference-poster")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/248")]
    ConferencePoster,
    /// Workflow
    #[display("workflow")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/249")]
    Workflow,
    /// Journal article
    #[display("journal-article")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/250")]
    JournalArticle,
    /// Standard
    #[display("standard")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/251")]
    Standard,
    /// Report
    #[display("report")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/252")]
    Report,
    /// Dissertation
    #[display("dissertation")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/253")]
    Dissertation,
    /// Preprint
    #[display("preprint")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/254")]
    Preprint,
    /// Data paper
    #[display("data-paper")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/255")]
    DataPaper,
    /// Computational notebook (e.g., Jupyter notebook)
    #[display("computational-notebook")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/256")]
    ComputationalNotebook,
    /// Image
    #[display("image")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/257")]
    Image,
    /// Book
    #[display("book")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/258")]
    Book,
    /// Software
    #[display("software")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/259")]
    Software,
    /// Event
    #[display("event")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/260")]
    Event,
    /// Sound
    #[display("sound")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/261")]
    Sound,
    /// Conference proceeding
    #[display("conference-proceeding")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/262")]
    ConferenceProceeding,
    /// Model
    #[display("model")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/263")]
    Model,
    /// Conference paper
    #[display("conference-paper")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/264")]
    ConferencePaper,
    /// Text
    #[display("text")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/265")]
    Text,
    /// Instrument
    #[display("instrument")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/266")]
    Instrument,
    /// Learning object
    #[display("learning-object")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/267")]
    LearningObject,
    /// Prize (excluding funded awards)
    #[display("prize")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/268")]
    Prize,
    /// Dataset
    #[display("dataset")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/269")]
    Dataset,
    /// Physical object
    #[display("physical-object")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/270")]
    PhysicalObject,
    /// Book chapter
    #[display("book-chapter")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/271")]
    BookChapter,
    /// Funding
    /// ### Note
    /// > Includes grants or other cash or in-kind awards, but not prizes
    #[display("funding")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/272")]
    Funding,
    /// Audiovisual
    #[display("audiovisual")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/273")]
    Audiovisual,
    /// Service
    #[display("service")]
    #[serde(rename = "https://vocabulary.raid.org/relatedObject.type.schema/274")]
    Service,
}
/// Organization role identifier
#[derive(Clone, Debug, Deserialize, Display, EnumIs, JsonSchema, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum OrganizationRoleType {
    /// Lead research organization
    #[display("lead-research-organization")]
    #[serde(rename = "https://vocabulary.raid.org/organisation.role.schema/182")]
    LeadResearchOrganization,
    /// Other research organization
    #[display("other-research-organization")]
    #[serde(rename = "https://vocabulary.raid.org/organisation.role.schema/183")]
    OtherResearchOrganization,
    /// Partner organization (i.e., a non-research organization, such as an industry, government, or community partner that is collaborating on the project or activity, as a research partner rather than a hired consultant or contractor)
    #[display("partner-organization")]
    #[serde(rename = "https://vocabulary.raid.org/organisation.role.schema/184")]
    PartnerOrganization,
    /// Contractor (i.e., a consulting organization hired by the project)
    #[display("contractor")]
    #[serde(rename = "https://vocabulary.raid.org/organisation.role.schema/185")]
    Contractor,
    /// Funder (i.e., an organization underwriting the research via a cash or in-kind grant, prize, or investment, but not otherwise listed as a research organization, partner organization or contractor)
    #[display("funder")]
    #[serde(rename = "https://vocabulary.raid.org/organisation.role.schema/186")]
    Funder,
    /// Facility (i.e., an organization providing access to physical or digital infrastructure, but not otherwise listed as a research organization, partner organization or contractor)
    #[display("facility")]
    #[serde(rename = "https://vocabulary.raid.org/organisation.role.schema/187")]
    Facility,
    /// Other Organiation not covered by the roles above
    #[display("other-organization")]
    #[serde(rename = "https://vocabulary.raid.org/organisation.role.schema/188")]
    OtherOrganization,
}
/// Represents a contributor's administrative position on a project (such as their position on a grant application)
///
/// <div class="warning">Use contributor role to define scientific or scholarly contributions</div>
#[derive(Clone, Debug, Deserialize, Display, JsonSchema, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum PositionType {
    /// Principal Investigator
    #[display("principal-investigator")]
    #[serde(rename = "https://vocabulary.raid.org/contributor.position.schema/307")]
    PrincipalInvestigator,
    /// Co-Investigator
    #[display("co-investigator")]
    #[serde(rename = "https://vocabulary.raid.org/contributor.position.schema/308")]
    CoInvestigator,
    /// Partner Investigator (e.g., industry, government, or community collaborator)
    #[display("partner-investigator")]
    #[serde(rename = "https://vocabulary.raid.org/contributor.position.schema/309")]
    PartnerInvestigator,
    /// Consultant (e.g., someone hired as a contract researcher by the project)
    #[display("consultant")]
    #[serde(rename = "https://vocabulary.raid.org/contributor.position.schema/310")]
    Consultant,
    /// Other Participant not covered by one of the positions above, e.g., "member" or "other significant contributor"
    #[display("other")]
    #[serde(rename = "https://vocabulary.raid.org/contributor.position.schema/311")]
    Other,
}
/// RAiD Relation Type
///
/// Describes the relationship being one activity and another
#[derive(Clone, Debug, Deserialize, Display, JsonSchema, Serialize)]
#[serde(rename_all = "kebab-case")]
pub enum RelatedRaidType {
    /// Obsoletes
    /// > For resolving duplicate RAiDs
    #[display("obsoletes")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/198")]
    Obsoletes,
    /// Is source of
    #[display("is-source-of")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/199")]
    IsSourceOf,
    /// Is derived from
    #[display("is-derived-from")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/200")]
    IsDerivedFrom,
    /// Has part
    #[display("has-part")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/201")]
    HasPart,
    /// Is part of
    #[display("is-part-of")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/202")]
    IsPartOf,
    /// Is continued by
    #[display("is-continued-by")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/203")]
    IsContinuedBy,
    /// Continues
    #[display("continues")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/204")]
    Continues,
    /// Is obsoleted by
    /// > For resolving duplicate RAiDs
    #[display("is-obsoleted-by")]
    #[serde(rename = "https://vocabulary.raid.org/relatedRaid.type.schema/205")]
    IsObsoletedBy,
}
/// Allowed values for title identifiers
#[derive(Clone, Debug, Deserialize, Display, EnumIs, JsonSchema, Serialize)]
pub enum TitleType {
    /// Title acronym
    #[display("acronym")]
    #[serde(rename = "https://vocabulary.raid.org/title.type.schema/156")]
    Acronym,
    /// Alternative title, including subtitle or other supplemental title
    #[display("alternative")]
    #[serde(rename = "https://vocabulary.raid.org/title.type.schema/4")]
    Alternative,
    /// Preferred full or long title
    #[display("primary")]
    #[serde(rename = "https://vocabulary.raid.org/title.type.schema/5")]
    Primary,
    /// Abreviated title
    #[display("short")]
    #[serde(rename = "https://vocabulary.raid.org/title.type.schema/157")]
    Short,
}
/// Metadata schema block containing RAiD access information
#[skip_serializing_none]
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[builder(start_fn = init)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Access {
    /// Access type
    #[validate(required, nested)]
    #[serde(rename = "type")]
    pub access_type: Option<AccessIdentifier>,
    /// Date an embargo on access to the RAiD metadata ends
    /// ### Format
    /// > [ISO 8601] standard date (e.g., `YYYY-MM-DD`)
    ///
    /// <div class="warning">Mandatory if access type is "embargoed"</div>
    ///
    /// <div class="warning">Embargo expiration dates may not lay more than 18 months from the date the RAiD was registered. Year, month, and day mush be specified.</div>
    ///
    /// [ISO 8601]: https://en.wikipedia.org/wiki/ISO_8601
    #[validate(date)]
    pub embargo_expiry: Option<String>,
    /// Access statement
    ///
    /// <div class="warning">Mandatory if access type is not "open"</div>
    #[validate(nested)]
    pub statement: Option<AccessStatement>,
}
/// Access type identifier
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct AccessIdentifier {
    /// Type of access granted to a RAiD metadata record
    pub id: AccessType,
    /// URI of the access type schema
    #[builder(default = "https://vocabularies.coar-repositories.org/access_rights/".to_string())]
    #[validate(url)]
    pub schema_uri: String,
}
/// Metadata schema block containing an explanation for any access type that is not "open", with the explanation's associated properties
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct AccessStatement {
    /// The text of an access statement that explains any restrictions on access
    #[validate(length(min = 1, max = 1000))]
    pub text: Option<String>,
    /// The language of the access statement
    #[validate(nested)]
    pub language: Option<Language>,
}
/// Metadata schema block containing alternative local or global identifiers for the project or activity associated with the RAiD
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct AlternateIdentifier {
    /// Identifier other than the RAiD applied to the project or activity
    /// ### Example
    /// > ACORN research activity data (RAD) [identifier]
    ///
    /// [identifier]: ./struct.Metadata.html#structfield.identifier
    pub id: String,
    /// Free text description of the type of alternate identifier supplied
    #[serde(rename = "type")]
    pub alternate_identifier_type: String,
}
/// Link to another website related to the project or activity
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct AlternateUrl {
    #[validate(url)]
    url: String,
}
/// Metadata schema block containing a contributor to a RAiD and their associated properties
///
/// See <https://metadata.raid.org/en/v1.6/core/contributors.html>
#[skip_serializing_none]
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[builder(start_fn = init, on(String, into))]
#[validate(schema(function = "validate_contributor_identifier", skip_on_field_errors = false))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Contributor {
    /// Contributor (person) associated with a project or activity identified by a persistent identifier (PID)
    ///
    /// Should be a valid full ORCID or ISNI resolver URL.
    /// ### Example
    /// > "<https://orcid.org/0000-0000-0000-0000>"
    /// > "<https://isni.org/isni/0000000492299539>"
    #[validate(required)]
    pub id: Option<String>,
    /// URI of the contributor identifier schema
    ///
    /// <div class="warning">PID is required and (currently) only [ORCID] and [ISNI] are allowed</div>
    ///
    /// [ISNI]: https://isni.org/
    /// [ORCID]: https://orcid.org/
    #[validate(required, url)]
    pub schema_uri: Option<String>,
    /// Contibutor status
    // TODO: Not in schema docs
    pub status: Option<String>,
    /// Text describing status
    pub status_message: Option<String>,
    /// Contributor's administrative position on a project or activity
    // TODO: Schema docs list position as singular
    #[validate(nested)]
    pub position: Vec<ContributorPosition>,
    /// Flag indicating that the contributor as a project leader
    #[builder(default = false)]
    pub leader: bool,
    /// Flag indicating that the contributor as a project contact
    #[builder(default = false)]
    pub contact: bool,
    /// Contributor email
    // TODO: Not in schema docs
    #[validate(email)]
    pub email: Option<String>,
    /// Contributor's role(s) on a project or activity
    #[validate(nested)]
    pub role: Option<Vec<Role>>,
    /// Contributor UUID
    // TODO: Not in schema docs
    pub uuid: Option<String>,
}
/// Metadata schema sub-block describing a contributor's administrative position on a project or activity
///
/// See <https://metadata.raid.org/en/v1.6/core/contributors.html#contributor-position>
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct ContributorPosition {
    /// Contributor's administrative position in the project
    /// ### Example
    /// > "Principal Investigator"
    pub id: PositionType,
    /// URI of the position schema used
    ///
    /// <div class="warning">Controlled list of schemas is informed by Simon Cox's [Project Ontology], [OpenAIRE] "Project" guidelines, NIH definitions, ARC definitions, and DataCite Metadata Schema 4.4 Appendix 1 Table 5 "Description of contributorType".</div>
    ///
    /// [OpenAIRE]: https://guidelines.openaire.eu/en/latest/
    /// [Project Ontology]: http://linked.data.gov.au/def/project
    #[builder(default = "https://vocabulary.raid.org/contributor.position.schema/305".to_string())]
    #[validate(url)]
    pub schema_uri: String,
    /// Dates associated with contributor's involvement in a project or activity
    #[validate(custom(function = "has_start_date"), nested)]
    #[serde(flatten)]
    pub date: Date,
}
/// Metadata schema block containing the description of the RAiD and associated properties
///
/// See <https://metadata.raid.org/en/v1.6/core/descriptions.html>
#[skip_serializing_none]
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Description {
    /// Description text
    #[validate(required, length(min = 3, max = 1000))]
    pub text: Option<String>,
    /// Description type information
    #[validate(required, nested)]
    #[serde(rename = "type")]
    pub description_type: Option<DescriptionIdentifier>,
    /// Language of the description text
    #[validate(nested)]
    pub language: Option<Language>,
}
/// Metadata schema block declaring the type of description
#[derive(Builder, Clone, Debug, Deserialize, JsonSchema, Serialize, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct DescriptionIdentifier {
    /// Description identifier
    pub id: DescriptionType,
    /// URI of the associated description schema
    #[builder(default = "https://vocabulary.raid.org/description.type.schema/320".to_string())]
    #[validate(url)]
    pub schema_uri: String,
}
/// Read normalized discovery values from a collection of RAiD metadata records.
pub struct Extractor<'a> {
    records: &'a [Metadata],
}
/// Metadata schema block containing information about the associated type
#[derive(Builder, Clone, Debug, Deserialize, Serialize, JsonSchema, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Identifier {
    /// Type identifier
    pub id: String,
    /// URI of the associated type schema
    #[validate(url)]
    pub schema_uri: Option<String>,
}
/// Metadata schema sub-block containing free-text keyword describing a project plus associated properties
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Keyword {
    /// Unconstrained keyword or key phrase describing the project or activity
    pub text: String,
    /// Language of the keyword
    #[validate(nested)]
    pub language: Option<Language>,
}
/// Metadata schema block declaring the language of the associated text
#[derive(Builder, Clone, Debug, Deserialize, Serialize, JsonSchema, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Language {
    /// Language used for the associated text, identified by a code or another identifier
    /// ### Examples
    /// - "eng"
    /// - "fra"
    /// - "jpn"
    ///
    /// <div class="warning">Limited to <a href="https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes">ISO 639:2023 (Set 3)</a></div>
    #[validate(length(equal = 3))]
    pub id: String,
    /// URI of the associated type schema
    #[validate(url)]
    pub schema_uri: Option<String>,
}
/// Research Activity Identifier (RAiD) Metadata
#[skip_serializing_none]
#[derive(Builder, Clone, Debug, Display, eserde::Deserialize, Serialize, JsonSchema, Validate)]
#[builder(start_fn = init)]
#[display("({identifier:?})")]
#[validate(schema(function = "validate_metadata", skip_on_field_errors = false))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Metadata {
    /// Access for the RAiD metadata
    #[validate(required, nested)]
    #[eserde(compat)]
    pub access: Option<Access>,
    /// Contributors to the RAiD
    #[validate(required, nested, length(min = 1))]
    #[eserde(compat)]
    pub contributor: Option<Vec<Contributor>>,
    /// Dates associated with the RAiD metadata
    #[validate(required, custom(function = "has_start_date"), nested)]
    #[eserde(compat)]
    pub date: Option<Date>,
    /// Metadata schema block containing the RAiD name and associated properties
    #[validate(nested)]
    #[eserde(compat)]
    pub identifier: Option<MetadataIdentifier>,
    /// Title metadata of the RAiD
    ///
    /// <div class="warning">One and only one title should be identified as "primary"</div>
    #[validate(required, nested, length(min = 1))]
    #[eserde(compat)]
    pub title: Option<Vec<Title>>,
    /// Alternate identifiers associated with the RAiD
    #[validate(nested)]
    #[eserde(compat)]
    pub alternate_identifier: Option<Vec<AlternateIdentifier>>,
    /// Alternate URLs associated with the RAiD
    #[validate(nested)]
    #[eserde(compat)]
    pub alternate_url: Option<Vec<AlternateUrl>>,
    /// Description metadata of the RAiD
    #[validate(nested)]
    #[eserde(compat)]
    pub description: Option<Vec<Description>>,
    /// RAiD metadata metadata
    #[validate(nested)]
    #[eserde(compat)]
    pub metadata: Option<MetadataMetadata>,
    /// Organizations associated with the RAiD
    ///
    /// <div class="warning">If only one organization is listed, it's role defaults to "Lead Research Organization"</div>
    ///
    /// <div class="warning">One and only one organization should be identified as "Lead Research Organization"</div>
    #[validate(nested)]
    #[serde(alias = "organisation")]
    #[eserde(compat)]
    pub organization: Option<Vec<Organization>>,
    /// Related objects associated with the RAiD
    #[validate(nested)]
    #[eserde(compat)]
    pub related_object: Option<Vec<RelatedObject>>,
    /// Related RAiD(s) associated with the RAiD
    #[validate(nested)]
    #[eserde(compat)]
    pub related_raid: Option<Vec<RelatedRaid>>,
    /// Spatial coverage
    #[validate(nested)]
    #[eserde(compat)]
    pub spatial_coverage: Option<Vec<SpatialCoverage>>,
    /// Subjects
    #[validate(nested)]
    #[eserde(compat)]
    pub subject: Option<Vec<Subject>>,
    /// Traditional knowledge information
    #[validate(nested)]
    #[eserde(compat)]
    pub traditional_knowledge_label: Option<Vec<TraditionalKnowledgeLabel>>,
}
/// Metadata schema block containing the RAiD name and associated properties
///
/// See <https://metadata.raid.org/en/v1.6/core/identifier.html#identifier>
#[derive(Builder, Clone, Debug, Serialize, Deserialize, Display, JsonSchema, Validate)]
#[display("{id:?}")]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct MetadataIdentifier {
    /// Unique alphanumeric character string that identifies a Research Activity Identifier (RAiD) name
    /// ### Format
    /// > `https://raid.org/prefix/suffix`
    #[validate(required, raid)]
    pub id: Option<String>,
    /// URI of the identifier scheme used to identify RAiDs
    /// ### Example
    /// > `https://raid.org/`
    #[validate(required, url)]
    pub schema_uri: Option<String>,
    /// RAiD owner
    #[validate(required, nested)]
    pub owner: Option<Owner>,
    /// RAiD agency URL
    #[validate(required, url)]
    pub raid_agency_url: Option<String>,
    /// Mtadata schema sub-block declaring the Registration Agency that minted the RAiD
    #[validate(required, nested)]
    pub registration_agency: Option<RegistrationAgency>,
    /// The licence, or licence waiver, under which the RAiD metadata record associated with this Identifier has been issued
    ///
    /// <div class="warning">Only supports CC-0 (?)</div>
    #[validate(required, custom(function = "validate_license"))]
    pub license: Option<OneOrMany<String>>,
    /// Version number of the RAiD
    #[validate(required, range(min = 0))]
    pub version: Option<u32>,
}
/// Information about edit history of associated RAiD
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct MetadataMetadata {
    /// Date and time the RAiD metadata record was created
    ///
    /// Should be Unix epoch timestamp
    #[validate(unix_epoch)]
    pub created: usize,
    /// Date and time the RAiD metadata record was last updated
    ///
    /// Should be Unix epoch timestamp
    #[validate(unix_epoch)]
    pub updated: usize,
}
/// Metadata schema block containing the organization associated with a RAiD and its associated properties
///
/// See <https://metadata.raid.org/en/v1.6/core/organisations.html#organisation>
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Organization {
    /// Organization identifier
    /// ### Example
    /// > `https://ror.org/01qz5mb56`
    ///
    /// <div class="warning">Should be <a href="https://ror.org">ROR</a>, if available</div>
    #[validate(ror)]
    pub id: String,
    /// URI of the organization identifier schema
    ///
    /// Only allowed value: `https://ror.org/`
    #[validate(url, contains(pattern = "https://ror.org"))]
    pub schema_uri: Option<String>,
    /// Organization role
    #[validate(nested)]
    pub role: Vec<OrganizationRole>,
}
/// Organization role
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct OrganizationRole {
    /// Organization role identifier
    pub id: OrganizationRoleType,
    /// URI of the organization role identifier schema
    #[validate(url)]
    pub schema_uri: Option<String>,
    /// Date information associated with the organization role
    #[validate(custom(function = "has_start_date"), nested)]
    #[serde(flatten)]
    pub date: Date,
}
/// Metadata schema sub-block that declares the owner of the RAiD (i.e. the organization requesting the RAiD)
///
/// See <https://metadata.raid.org/en/v1.6/core/identifier.html#identifier-owner>
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Owner {
    /// Persistent identifier of the legal entity responsible for the RAiD
    ///
    /// *Default* ROR of the organization requesting the RAiD
    /// ### Example
    /// > `https://ror.org/01qz5mb56` (ORNL)
    #[validate(ror)]
    pub id: String,
    /// URI of the identifier scheme used to identify RAiDs
    /// ### Example
    /// > `https://ror.org/`
    #[validate(url)]
    pub schema_uri: Option<String>,
    /// Service point (SP) that requested the RAiD
    /// ### Example
    /// > `20000003`
    /// ### Notes
    /// - RAiD owners can have multiple SPs
    /// - SPs do not need to be legal entities
    /// - List of SPs is maintained by each [`RegistrationAgency`]
    pub service_point: usize,
}
/// Metadata schema sub-block containing free-text place names or descriptions plus associated metadata properties
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Place {
    /// Free text description of one or more geographic locations that are the subject or target of the project or activity; use to specify or describe a geographic location in a manner not covered by [`SpatialCoverage`].id
    /// ### Warning
    /// > Do not duplicate information from [`SpatialCoverage`].id above; do not use for organisational locations (which are derived from the organisation's ROR)
    pub text: Option<String>,
    /// Language of the text
    #[validate(nested)]
    pub language: Option<Language>,
}
/// Research Activity Identifier (RAiD)[^raid]
///
/// RAiDs are expressed in the form of `https://raid.org/prefix/suffix`, resolvable through the RAiD portal operated by the ARDC[^ardc] at <https://raid.org/> —though they may still be resolved through any DOI or handle resolver.
///
/// RAiDs are governed by [ISO 23527](https://www.iso.org/standard/75931.html)
///
/// [^ardc]: [Australian Research Data Commons](https://ardc.edu.au/)
#[derive(Builder, Clone, Debug)]
#[builder(start_fn = init, on(String, into))]
pub struct RAID {
    /// Schema URI (e.g., <https://www.raid.org/>)
    pub schema_uri: Option<String>,
    /// RAiD prefix value
    pub prefix: Option<String>,
    /// RAiD suffix value
    pub suffix: Option<String>,
    /// RAiD metadata
    ///
    /// Metadata associated with identifier. See <https://metadata.raid.org> for more information.
    pub metadata: Option<Metadata>,
}
/// Metadata schema block containing the RAiD name and associated properties
///
/// See <https://metadata.raid.org/en/v1.6/core/identifier.html#identifier-registrationagency>
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct RegistrationAgency {
    /// Persistent identifier of the RAiD Registration Agency that minted the RAiD
    ///
    /// *Default* ROR of the RAiD Registration Agency
    #[validate(ror)]
    pub id: String,
    /// URI of the identifier scheme used to identify RAiDs
    /// ### Example
    /// > `https://raid.org/`
    #[validate(url)]
    pub schema_uri: Option<String>,
}
// Metadata schema block containing inputs, outputs, and process documents related to a RAiD plus associated properties
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct RelatedObject {
    /// Persistent identifier (PID) of related object
    ///
    /// The object can be any combination of
    /// - input or resource used by a project or activity
    /// - output or product created by a project or activity
    /// - internal process documentation used within a project or activity
    pub id: String,
    /// URI of the relatedObject identifier schema
    #[validate(url)]
    pub schema_uri: Option<String>,
    /// Type information of related object
    #[validate(nested)]
    #[serde(rename = "type")]
    pub related_object_type: RelatedObjectIdentifier,
    /// Category information of related object
    #[validate(nested, length(min = 1))]
    pub category: Vec<RelatedObjectCategory>,
}
/// Related object category information
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct RelatedObjectCategory {
    /// Related object category identifier
    pub id: ObjectCategoryType,
    /// URI of the category schema used
    #[validate(url)]
    pub schema_uri: Option<String>,
}
/// Related object identifier
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct RelatedObjectIdentifier {
    /// Related object type identifier
    pub id: ObjectType,
    /// URI of the related object type identifier schema
    #[validate(url)]
    pub schema_uri: Option<String>,
}
/// Metadata schema block containing related RAiDs and qualifying the relationship
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct RelatedRaid {
    /// Subsidiary or otherwise related RAiD
    pub id: String,
    /// Related RAiD type
    #[validate(nested)]
    #[serde(rename = "type")]
    pub related_raid_type: RelatedRaidIdentifier,
}
/// Related RAiD identifier
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct RelatedRaidIdentifier {
    /// Related RAiD type identifier
    pub id: RelatedRaidType,
    /// URI of the related RAiD type identifier schema
    #[validate(url)]
    pub schema_uri: Option<String>,
}
/// Metadata schema sub-block describing a contributor's scientific or scholarly role on a project using the [CRediT] vocabulary
///
/// See <https://metadata.raid.org/en/v1.6/core/contributors.html#contributor-role>
///
/// [CRediT]: https://credit.niso.org/
#[skip_serializing_none]
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[builder(start_fn = init, on(String, into))]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Role {
    /// Contributor role on a project or activity
    #[validate(required)]
    pub id: Option<CreditRole>,
    /// URI of the role schema used
    #[builder(default = "https://credit.niso.org/".to_string())]
    #[validate(url)]
    pub schema_uri: String,
}
/// Metadata schema block containing information about any spatial region(s) or named place(s) targeted by the project
/// ### Note
/// > Part of "extended" metadata that allows some customization by Registration Agencies
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct SpatialCoverage {
    /// Spatial region or named place that is the subject or target of the project or activity. Repeat this property as necessary to indicate different locations. Do not duplicate organisational locations
    pub id: String,
    /// URI of the geolocation schema used for spatial coverage
    #[validate(url)]
    pub schema_uri: Option<String>,
    /// Places of associated spatial coverage
    #[validate(nested)]
    pub place: Vec<Place>,
}
/// Metadata schema block containing the subject area of the RAiD plus associated properties
/// ### Note
/// > Part of "extended" metadata that allows some customization by Registration Agencies
#[derive(Builder, Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Subject {
    /// URI for a subject area or classification code describing the project or activity
    pub id: String,
    /// URI of the subject identifier schema
    #[validate(url)]
    pub schema_uri: Option<String>,
    /// Subject keywords
    #[validate(required, nested)]
    pub keyword: Option<Vec<Keyword>>,
}
/// Metadata schema block containing the title of RAiD and associated properties
///
/// See <https://metadata.raid.org/en/v1.6/core/titles.html>
#[skip_serializing_none]
#[derive(Builder, Clone, Debug, Display, Serialize, Deserialize, JsonSchema, Validate)]
#[builder(start_fn = init, on(String, into))]
#[display("{text:?} ({title_type:?})")]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct Title {
    /// Name or title by which the project or activity is known
    #[validate(required, length(min = 3, max = 100))]
    pub text: Option<String>,
    /// Metadata schema block containing information about the title type
    #[validate(required, nested)]
    #[serde(rename = "type")]
    pub title_type: Option<TitleIdentifier>,
    /// Language of the title
    #[validate(nested)]
    pub language: Option<Language>,
    /// Date the project or activity's title began being used
    /// ### Format
    /// > [ISO 8601] standard date (e.g., `YYYY-MM-DD`)
    ///
    /// [ISO 8601]: https://en.wikipedia.org/wiki/ISO_8601
    #[validate(required, date)]
    pub start_date: Option<String>,
    /// Date the project or activity title was changed or stopped being used
    /// ### Format
    /// > [ISO 8601] standard date (e.g., `YYYY-MM-DD`)
    ///
    /// <div class="warning">Only the year is required, month and day are optional</div>
    ///
    /// <div class="warning">Listed as "recommended" (optional) and "required"</div>
    ///
    /// [ISO 8601]: https://en.wikipedia.org/wiki/ISO_8601
    #[validate(year)]
    pub end_date: Option<String>,
}
/// Metadata schema block containing information about the title type
#[derive(Builder, Clone, Debug, Serialize, Deserialize, Display, JsonSchema, Validate)]
#[builder(start_fn = init, on(String, into))]
#[display("{id}")]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct TitleIdentifier {
    /// Title type
    ///
    /// <div class="warning">Only one title should be identified as "Primary"</div>
    pub id: TitleType,
    /// URI of the title type schema
    #[builder(default = "https://vocabulary.raid.org/title.type.schema/376".to_string())]
    #[validate(url)]
    pub schema_uri: String,
}
/// Metadata schema block containing information about Traditional Knowledge / Biocultural Labels and Notices
/// ### Note
/// > Part of "extended" metadata that allows some customization by Registration Agencies
#[derive(Clone, Debug, Serialize, Deserialize, JsonSchema, Validate)]
#[serde(deny_unknown_fields, rename_all = "camelCase")]
pub struct TraditionalKnowledgeLabel {
    /// Identifier (URI) linking to a verified source for Traditional Knowledge (TK) or Biocultural (BC) Labels or Notices pertaining to a project or activity
    /// ### Note
    /// > Currently only Local Contexts Hub Projects are allowed as a source for validated TK/BC Labels and Notices.
    pub id: String,
    /// URI of the Traditional Knowledge or Biocultural label identifier schema
    /// ### Note
    /// > Currently only Local Contexts Hub is supported for validated TK/BC Labels and Notices.
    #[validate(url)]
    pub schema_uri: Option<String>,
}
impl AlternateUrl {
    /// Return the alternate project URL.
    pub fn url(&self) -> &str {
        &self.url
    }
}
impl Contributor {
    fn is_contact(&self) -> bool {
        self.contact
    }
    fn is_leader(&self) -> bool {
        self.leader
    }
}
impl TryFrom<&str> for CreditRole {
    type Error = &'static str;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        match value
            .trim()
            .trim_end_matches('/')
            .rsplit('/')
            .next()
            .unwrap_or_default()
            .to_ascii_lowercase()
            .as_str()
        {
            | "conceptualization" => Ok(Self::Conceptualization),
            | "data-curation" => Ok(Self::DataCuration),
            | "formal-analysis" => Ok(Self::FormalAnalysis),
            | "funding-acquisition" => Ok(Self::FundingAcquisition),
            | "investigation" => Ok(Self::Investigation),
            | "methodology" => Ok(Self::Methodology),
            | "project-administration" => Ok(Self::ProjectAdministration),
            | "resources" => Ok(Self::Resources),
            | "software" => Ok(Self::Software),
            | "supervision" => Ok(Self::Supervision),
            | "validation" => Ok(Self::Validation),
            | "visualization" => Ok(Self::Visualization),
            | "writing-original-draft" => Ok(Self::WritingOriginalDraft),
            | "writing-review-editing" => Ok(Self::WritingReviewEditing),
            | _ => Err("unknown CRediT role"),
        }
    }
}
impl<'a> Extractor<'a> {
    /// Create an extractor over RAiD metadata records.
    pub fn new(records: &'a [Metadata]) -> Self {
        Self { records }
    }
    fn titles(&self) -> impl Iterator<Item = &Title> {
        self.records.iter().flat_map(|record| record.title.iter().flatten())
    }
    /// Return the primary title, falling back to the first non-empty title.
    pub fn title(&self) -> Option<String> {
        self.titles()
            .filter(|title| title.title_type.as_ref().is_some_and(|kind| kind.id.is_primary()))
            .find_map(|title| title.text.as_ref().filter(|value| !value.trim().is_empty()))
            .cloned()
            .or_else(|| {
                self.titles()
                    .find_map(|title| title.text.as_ref().filter(|value| !value.trim().is_empty()))
                    .cloned()
            })
    }
    /// Return the single distinct explicit contact identifier and email.
    pub fn contact(&self) -> Option<(Option<String>, Option<String>)> {
        let contacts = self
            .records
            .iter()
            .flat_map(|record| record.contributor.iter().flatten())
            .filter(|contributor| contributor.contact)
            .map(|contributor| {
                (
                    contributor.id.clone().filter(|value| !value.trim().is_empty()),
                    contributor.email.clone().filter(|value| !value.trim().is_empty()),
                )
            })
            .filter(|(identifier, email)| identifier.is_some() || email.is_some())
            .collect::<BTreeSet<_>>();
        (contacts.len() == 1).then(|| contacts.into_iter().next()).flatten()
    }
    /// Return controlled organization names mapped as sponsors or partners by RAiD role.
    pub fn organization_names(&self, sponsors: bool) -> Vec<String> {
        self.records
            .iter()
            .flat_map(|record| {
                let organizations = record.organization.as_deref().unwrap_or_default();
                organizations.iter().filter(move |organization| {
                    let is_funder = organization.role.iter().any(|role| role.id.is_funder());
                    let is_partner =
                        (organizations.len() == 1 && organization.role.is_empty()) || organization.role.iter().any(|role| !role.id.is_funder());
                    match sponsors {
                        | true => is_funder,
                        | false => is_partner,
                    }
                })
            })
            .filter_map(|organization| {
                let vocabularies = match sponsors {
                    | true => ["sponsors", "partners"],
                    | false => ["partners", "sponsors"],
                };
                let ror = organization.id.trim_end_matches('/').rsplit('/').next().unwrap_or(&organization.id);
                vocabularies.iter().flat_map(vocabulary::csv).find_map(|row| match row.as_slice() {
                    | [name, _, value, ..] if value.eq_ignore_ascii_case(ror) => Some(name.clone()),
                    | _ => None,
                })
            })
            .collect::<BTreeSet<_>>()
            .into_iter()
            .collect()
    }
}
impl Metadata {
    /// Print research activity identifier (RAiD) metadata schema as JSON or YAML schema
    #[cfg(feature = "std")]
    pub fn to_schema(format: &str) {
        let schema = schema_for!(Metadata);
        let output = match format.to_lowercase().as_str() {
            | "yaml" | "yml" => serde_norway::to_string(&schema).unwrap_or_default(),
            | _ => serde_json::to_string_pretty(&schema).unwrap_or_default(),
        };
        println!("{output}");
    }
}
impl From<&str> for ObjectType {
    fn from(value: &str) -> Self {
        match value.trim().to_ascii_lowercase().replace([' ', '_'], "-").as_str() {
            | "audiovisual" => Self::Audiovisual,
            | "book" => Self::Book,
            | "bookchapter" | "book-chapter" => Self::BookChapter,
            | "computationalnotebook" | "computational-notebook" => Self::ComputationalNotebook,
            | "conferencepaper" | "conference-paper" => Self::ConferencePaper,
            | "conferenceproceeding" | "conference-proceeding" => Self::ConferenceProceeding,
            | "datapaper" | "data-paper" => Self::DataPaper,
            | "dataset" => Self::Dataset,
            | "dissertation" => Self::Dissertation,
            | "event" => Self::Event,
            | "funding" => Self::Funding,
            | "image" => Self::Image,
            | "instrument" => Self::Instrument,
            | "learningobject" | "learning-object" => Self::LearningObject,
            | "model" => Self::Model,
            | "outputmanagementplan" | "output-management-plan" => Self::OutputManagementPlan,
            | "physicalobject" | "physical-object" => Self::PhysicalObject,
            | "poster" | "conference-poster" => Self::ConferencePoster,
            | "preprint" => Self::Preprint,
            | "report" => Self::Report,
            | "service" => Self::Service,
            | "software" => Self::Software,
            | "sound" => Self::Sound,
            | "standard" => Self::Standard,
            | "workflow" => Self::Workflow,
            | _ => Self::Text,
        }
    }
}
impl Organization {
    fn is_lead_research_organization(&self) -> bool {
        self.role.iter().any(|role| role.id.is_lead_research_organization())
    }
}
impl From<&str> for OrganizationRoleType {
    fn from(value: &str) -> Self {
        match value.trim().to_ascii_lowercase().replace([' ', '_'], "-").as_str() {
            | "contractor" => Self::Contractor,
            | "facility" => Self::Facility,
            | "funder" => Self::Funder,
            | "lead-research-organization" | "lead-research-organisation" => Self::LeadResearchOrganization,
            | "other-research-organization" | "other-research-organisation" => Self::OtherResearchOrganization,
            | "partner-organization" | "partner-organisation" => Self::PartnerOrganization,
            | _ => Self::OtherOrganization,
        }
    }
}
impl TryFrom<&str> for PositionType {
    type Error = &'static str;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        match value.trim().to_ascii_lowercase().replace([' ', '_'], "-").as_str() {
            | "co-investigator" => Ok(Self::CoInvestigator),
            | "consultant" => Ok(Self::Consultant),
            | "other" => Ok(Self::Other),
            | "partner-investigator" => Ok(Self::PartnerInvestigator),
            | "principal-investigator" => Ok(Self::PrincipalInvestigator),
            | _ => Err("unknown contributor position"),
        }
    }
}
impl Default for RAID {
    fn default() -> Self {
        Self::new()
    }
}
impl fmt::Display for RAID {
    /// Format a RAID into a standard format of `"{prefix}/{suffix}"`
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let result = self.identifier();
        write!(f, "{result}")
    }
}
impl PersistentIdentifier for RAID {
    fn new() -> Self {
        RAID::init().build()
    }
    fn schema_uri(&self) -> String {
        self.schema_uri.as_ref().cloned().unwrap_or_default().trim_end_matches("/").to_string()
    }
    fn prefix(&self) -> Option<String> {
        self.prefix.clone()
    }
    fn suffix(&self) -> Option<String> {
        self.suffix.clone()
    }
    fn identifier(&self) -> String {
        let values = [self.prefix(), self.suffix()];
        values
            .iter()
            .flatten()
            .filter(|x| !x.is_empty())
            .map(String::from)
            .collect::<Vec<String>>()
            .join("/")
    }
}
impl PersistentIdentifierParse for RAID {
    /// Find all [`RAID`] values present in a string
    fn find_all(value: impl ToString) -> Vec<Self> {
        let re = &RE_DOI;
        re.find_iter(&value.to_string())
            .filter_map(Result::ok)
            .map(|m| RAID::from_string(trim_unmatched_trailing_parentheses(m.as_str())))
            .collect()
    }
    /// Convenience method for easily parsing and formatting a [`RAID`] from a string value
    /// ### Example
    /// ```rust
    /// use acorn_schema::pid::{RAID, PersistentIdentifierParse};
    ///
    /// assert_eq!(RAID::format("https://raid.org/10.83962/fb5be317"), "10.83962/fb5be317");
    /// ```
    fn format(value: impl ToString) -> String {
        RAID::from_string(value).to_string()
    }
    /// Create new [`RAID`] by parsing a raw string value
    /// ### Note
    /// > RAiD identifiers are [DOI](crate::pid::DOI) identifiers. See this [blog post by DataCite](https://datacite.org/blog/datacite-ardc-announce-partnership-to-deliver-the-raid-service/) for details.
    fn from_string(value: impl ToString) -> Self {
        let groups = ["schema_uri", "directory_indicator", "registrant_code", "suffix"];
        let pattern = format!("^{RE_RAID_TEXT}$");
        let text = value.to_string().trim().to_string();
        let lookup = regex_capture_lookup(pattern.as_ref(), text.as_ref(), groups.to_vec());
        let directory_indicator = lookup.get("directory_indicator").cloned();
        let registrant_code = lookup.get("registrant_code").cloned();
        let prefix = [directory_indicator, registrant_code]
            .into_iter()
            .flatten()
            .collect::<Vec<String>>()
            .join(".");
        RAID::init()
            .prefix(prefix)
            .maybe_schema_uri(lookup.get("schema_uri").cloned())
            .maybe_suffix(lookup.get("suffix").cloned())
            .build()
    }
    /// Check if value is a valid [`RAID`]
    /// > See `DOI::is_valid` for conditions, as RAiD identifiers are [DOIs](crate::pid::DOI).
    fn is_valid(value: impl ToString) -> bool {
        let pid = RAID::from_string(value.to_string());
        let prefix_is_valid = match pid.prefix() {
            | Some(x) => x.replace(".", "").is_numeric() && !x.eq("10.5555"),
            | _ => false,
        };
        let suffix_is_valid = pid.suffix().is_some();
        prefix_is_valid && suffix_is_valid
    }
}
impl TryFrom<&str> for RelatedRaidType {
    type Error = &'static str;

    fn try_from(value: &str) -> Result<Self, Self::Error> {
        match value.trim().to_ascii_lowercase().replace([' ', '_'], "-").as_str() {
            | "continues" => Ok(Self::Continues),
            | "has-part" => Ok(Self::HasPart),
            | "is-continued-by" => Ok(Self::IsContinuedBy),
            | "is-derived-from" => Ok(Self::IsDerivedFrom),
            | "is-obsoleted-by" => Ok(Self::IsObsoletedBy),
            | "is-part-of" => Ok(Self::IsPartOf),
            | "is-source-of" => Ok(Self::IsSourceOf),
            | "obsoletes" => Ok(Self::Obsoletes),
            | _ => Err("unknown related RAiD type"),
        }
    }
}
fn has_start_date(value: &Date) -> Result<(), ValidationError> {
    match value.start_date.as_ref() {
        | Some(start_date) if !start_date.trim().is_empty() => Ok(()),
        | _ => Err(ValidationError::new("date").with_message("Provide valid start date")),
    }
}
fn validate_contributor_identifier(value: &Contributor, _context: &()) -> Result<(), ValidationReport> {
    match (value.id.as_deref(), value.schema_uri.as_deref().map(|uri| uri.trim_end_matches('/'))) {
        | (Some(identifier), Some("https://orcid.org")) => identifier
            .is_orcid()
            .then_some(())
            .ok_or_else(|| ValidationError::new("ORCiD").with_message("Provide valid ORCiD value"))
            .map_err(|error| error.into_report("")),
        | (Some(identifier), Some("https://isni.org")) => identifier
            .is_isni()
            .then_some(())
            .ok_or_else(|| ValidationError::new("ISNI").with_message("Provide valid ISNI value"))
            .map_err(|error| error.into_report("")),
        | (Some(_), Some(_)) => Err(ValidationError::new("contributor.identifier")
            .with_message("Contributor schemaUri must be https://orcid.org/ or https://isni.org/")
            .into_report("")),
        | _ => Ok(()),
    }
}
fn validate_contributors(value: &Metadata, _context: &()) -> Result<(), ValidationReport> {
    value.contributor.as_ref().map_or(Ok(()), |contributors| {
        let contact = match contributors.iter().any(Contributor::is_contact) {
            | true => ValidationReport::default(),
            | false => ValidationError::new("contact")
                .with_message("Mark at least one contributor as contact")
                .into_report("contributor.contact"),
        };
        let leader = match contributors.iter().any(Contributor::is_leader) {
            | true => ValidationReport::default(),
            | false => ValidationError::new("leader")
                .with_message("Mark at least one contributor as leader")
                .into_report("contributor.leader"),
        };
        contact.merge("", leader).finish()
    })
}
fn validate_metadata(value: &Metadata, context: &()) -> Result<(), ValidationReport> {
    ValidationReport::default()
        .merge("", report_of(validate_contributors(value, context)))
        .merge("", report_of(validate_organization(value, context)))
        .finish()
}
fn validate_organization(value: &Metadata, _context: &()) -> Result<(), ValidationReport> {
    value.organization.as_ref().map_or(Ok(()), |organizations| {
        let lead_count = organizations
            .iter()
            .filter(|organization| organization.is_lead_research_organization())
            .count();
        match (organizations.is_empty(), lead_count) {
            | (true, _) | (_, 1) => Ok(()),
            | (_, 0) => Err(ValidationError::new("organization")
                .with_message("Mark one organization as lead research organization")
                .into_report("organization")),
            | _ => Err(ValidationError::new("organization")
                .with_message("Only one organization can be lead research organization")
                .into_report("organization")),
        }
    })
}

#[cfg(all(test, feature = "std"))]
mod tests;