// Generated by ts-to-zod
import { z } from 'zod'

export const attributesSchema = z.record(z.union([z.string(), z.undefined()]).nullable())

const textSchema = z.object({
  type: z.literal('text'),
  value: z.string(),
})

const commentSchema = z.object({
  type: z.literal('comment'),
  value: z.string(),
})

const cDataSchema = z.object({
  type: z.literal('cdata'),
  value: z.string(),
})

const instructionSchema = z.object({
  type: z.literal('instruction'),
  name: z.string(),
  value: z.string(),
})

const fakerElementSchema = z.object({
  type: z.literal('element'),
  name: z.string(),
  attributes: z.union([attributesSchema, z.undefined()]).optional(),
  children: z.array(
    z.union([
      z.object({
        type: z.string(),
        name: z.string().optional(),
        attributes: z.record(z.any()).optional(),
        children: z.array(z.any()),
      }),
      textSchema,
      commentSchema,
      instructionSchema,
      cDataSchema,
    ]),
  ),
})

const fakeElementSchema = z.object({
  type: z.literal('element'),
  name: z.string(),
  attributes: z.union([attributesSchema, z.undefined()]).optional(),
  children: z.array(
    z.union([fakerElementSchema, textSchema, commentSchema, instructionSchema, cDataSchema]),
  ),
})

export const elementSchema = z.object({
  type: z.literal('element'),
  name: z.string(),
  attributes: z.union([attributesSchema, z.undefined()]).optional(),
  children: z.array(
    z.union([fakeElementSchema, textSchema, commentSchema, instructionSchema, cDataSchema]),
  ),
})

const textElementSchema = elementSchema.extend({
  children: z.tuple([textSchema]),
})

export const conferenceDateTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(0).max(100),
    }),
  ]),
})

export const pidSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().regex(/[hH][tT][tT][pP][sS]:\/\/.{1,50}/),
    }),
  ]),
})

export const organizationTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(511),
    }),
  ]),
})

export const orcidTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().regex(/https?:\/\/orcid.org\/[0-9]{4}-[0-9]{4}-[0-9]{4}-[0-9]{3}[X0-9]{1}/),
    }),
  ]),
})

export const itemNumberTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(32),
    }),
  ]),
})

export const identifierTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const formatTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(0).max(130),
    }),
  ]),
})

export const resourceTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(1)
        .max(2048)
        .regex(/([hH][tT][tT][pP]|[hH][tT][tT][pP][sS]|[fF][tT][pP]):\/\/.*/),
    }),
  ]),
})

export const cmAssertionSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(1024),
    }),
  ]),
})

export const isbnTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(10)
        .max(17)
        .regex(/(97(8|9)-)?\d[\d \-]+[\dX]/),
    }),
  ]),
})

export const issnTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(8)
        .max(9)
        .regex(/\d{4}-?\d{3}[\dX]/),
    }),
  ]),
})

export const citationTSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.string(),
})

export const aSchema = textElementSchema.extend({
  type: z.literal('element'),
  name: z.literal('a'),
  attributes: z.object({
    href: z.string(),
  }),
})

export const abbrevTitleSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(150),
    }),
  ]),
})

export const abbrevTitlePrimitiveTypeSchema = z.string().min(1).max(150)

export const approvedMonthSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(2),
    }),
  ]),
})

export const stdAltAsPublishedApprovedMonthSchema = z.string()

export const approvedYearSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const stdAltAsPublishedApprovedYearSchema = z.string()

export const articleTitleSchema = elementSchema.extend({
  name: z.literal('article_title'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const assertionSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('assertion'),
  attributes: z.object({
    explanation: z.string(),
    group_label: z.string(),
    group_name: z.string(),
    href: z.string(),
    label: z.string(),
    name: z.string(),
    order: z.string(),
  }),
  children: z.tuple([]),
})

export const authenticatedSchema = elementSchema.extend({
  name: z.literal('authenticated'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const authorSchema = elementSchema.extend({
  name: z.literal('author'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const xrefFacesSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('xrefFaces'),
  children: z.tuple([]),
})

export const bookBookTypeSchema = z.union([
  z.literal('edited_book'),
  z.literal('monograph'),
  z.literal('reference'),
  z.literal('other'),
])

export const citationSchema = citationTSchema.extend({
  type: z.literal('element'),
  name: z.literal('citation'),
  attributes: z.object({
    key: z.string(),
  }),
})

export const citationListSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('citation_list'),
  children: z.array(citationSchema),
})

export const codenSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(6),
    }),
  ]),
})

export const codenPrimitiveTypeSchema = z.string().min(1).max(6)

export const componentNumberSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(50),
    }),
  ]),
})

export const componentNumberPrimitiveTypeSchema = z.string().min(1).max(50)

export const componentSizeSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const componentComponentSizeSchema = z.string()

export const contentItemComponentTypeSchema = z.union([
  z.literal('chapter'),
  z.literal('section'),
  z.literal('part'),
  z.literal('track'),
  z.literal('reference_entry'),
  z.literal('other'),
])

export const conferenceAcronymSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(127),
    }),
  ]),
})

export const conferenceAcronymPrimitiveTypeSchema = z.string().min(1).max(127)

export const conferenceDateSchema = conferenceDateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('conference_date'),
  attributes: z.object({
    end_day: z.string().optional(),
    end_month: z.string().optional(),
    end_year: z.string().optional(),
    start_day: z.string().optional(),
    start_month: z.string().optional(),
    start_year: z.string().optional(),
  }),
})

export const conferenceLocationSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(255),
    }),
  ]),
})

export const conferenceLocationPrimitiveTypeSchema = z.string().min(2).max(255)

export const conferenceNameSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(3).max(512),
    }),
  ]),
})

export const conferenceNamePrimitiveTypeSchema = z.string().min(3).max(512)

export const conferenceNumberSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(15),
    }),
  ]),
})

export const conferenceNumberPrimitiveTypeSchema = z.string().min(1).max(15)

export const conferenceSponsorSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const conferenceSponsorPrimitiveTypeSchema = z.string().min(1).max(255)

export const conferenceThemeSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const conferenceThemePrimitiveTypeSchema = z.string().min(1).max(255)

export const resourceContentVersionSchema = z.union([z.literal('vor'), z.literal('am')])

export const contractNumberSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(255),
    }),
  ]),
})

export const contractNumberPrimitiveTypeSchema = z.string().min(2).max(255)

export const contributorRoleSchema = z.union([
  z.literal('author'),
  z.literal('editor'),
  z.literal('chair'),
  z.literal('reviewer'),
  z.literal('review-assistant'),
  z.literal('stats-reviewer'),
  z.literal('reviewer-external'),
  z.literal('reader'),
  z.literal('translator'),
])

export const itemCountrySchema = z.union([
  z.literal('AD'),
  z.literal('AE'),
  z.literal('AF'),
  z.literal('AG'),
  z.literal('AI'),
  z.literal('AL'),
  z.literal('AM'),
  z.literal('AN'),
  z.literal('AO'),
  z.literal('AQ'),
  z.literal('AR'),
  z.literal('AS'),
  z.literal('AT'),
  z.literal('AU'),
  z.literal('AW'),
  z.literal('AX'),
  z.literal('AZ'),
  z.literal('BA'),
  z.literal('BB'),
  z.literal('BD'),
  z.literal('BE'),
  z.literal('BF'),
  z.literal('BG'),
  z.literal('BH'),
  z.literal('BI'),
  z.literal('BJ'),
  z.literal('BL'),
  z.literal('BM'),
  z.literal('BN'),
  z.literal('BO'),
  z.literal('BQ'),
  z.literal('BR'),
  z.literal('BS'),
  z.literal('BT'),
  z.literal('BV'),
  z.literal('BW'),
  z.literal('BY'),
  z.literal('BZ'),
  z.literal('CA'),
  z.literal('CC'),
  z.literal('CD'),
  z.literal('CF'),
  z.literal('CG'),
  z.literal('CH'),
  z.literal('CI'),
  z.literal('CK'),
  z.literal('CL'),
  z.literal('CM'),
  z.literal('CN'),
  z.literal('CO'),
  z.literal('CR'),
  z.literal('CS'),
  z.literal('CU'),
  z.literal('CV'),
  z.literal('CX'),
  z.literal('CY'),
  z.literal('CZ'),
  z.literal('DE'),
  z.literal('DJ'),
  z.literal('DK'),
  z.literal('DM'),
  z.literal('DO'),
  z.literal('DZ'),
  z.literal('EC'),
  z.literal('EE'),
  z.literal('EG'),
  z.literal('EH'),
  z.literal('ER'),
  z.literal('ES'),
  z.literal('ET'),
  z.literal('FI'),
  z.literal('FJ'),
  z.literal('FK'),
  z.literal('FM'),
  z.literal('FO'),
  z.literal('FR'),
  z.literal('GA'),
  z.literal('GB'),
  z.literal('GD'),
  z.literal('GE'),
  z.literal('GF'),
  z.literal('GG'),
  z.literal('GH'),
  z.literal('GI'),
  z.literal('GL'),
  z.literal('GM'),
  z.literal('GN'),
  z.literal('GP'),
  z.literal('GQ'),
  z.literal('GR'),
  z.literal('GS'),
  z.literal('GT'),
  z.literal('GU'),
  z.literal('GW'),
  z.literal('GY'),
  z.literal('HK'),
  z.literal('HM'),
  z.literal('HN'),
  z.literal('HR'),
  z.literal('HT'),
  z.literal('HU'),
  z.literal('ID'),
  z.literal('IE'),
  z.literal('IL'),
  z.literal('IM'),
  z.literal('IN'),
  z.literal('IO'),
  z.literal('IQ'),
  z.literal('IR'),
  z.literal('IS'),
  z.literal('IT'),
  z.literal('JE'),
  z.literal('JM'),
  z.literal('JO'),
  z.literal('JP'),
  z.literal('KE'),
  z.literal('KG'),
  z.literal('KH'),
  z.literal('KI'),
  z.literal('KM'),
  z.literal('KN'),
  z.literal('KP'),
  z.literal('KR'),
  z.literal('KW'),
  z.literal('KY'),
  z.literal('KZ'),
  z.literal('LA'),
  z.literal('LB'),
  z.literal('LC'),
  z.literal('LI'),
  z.literal('LK'),
  z.literal('LR'),
  z.literal('LS'),
  z.literal('LT'),
  z.literal('LU'),
  z.literal('LV'),
  z.literal('LY'),
  z.literal('MA'),
  z.literal('MC'),
  z.literal('MD'),
  z.literal('ME'),
  z.literal('MF'),
  z.literal('MG'),
  z.literal('MH'),
  z.literal('MK'),
  z.literal('ML'),
  z.literal('MM'),
  z.literal('MN'),
  z.literal('MO'),
  z.literal('MP'),
  z.literal('MQ'),
  z.literal('MR'),
  z.literal('MS'),
  z.literal('MT'),
  z.literal('MU'),
  z.literal('MV'),
  z.literal('MW'),
  z.literal('MX'),
  z.literal('MY'),
  z.literal('MZ'),
  z.literal('NA'),
  z.literal('NC'),
  z.literal('NE'),
  z.literal('NF'),
  z.literal('NG'),
  z.literal('NI'),
  z.literal('NL'),
  z.literal('NO'),
  z.literal('NP'),
  z.literal('NR'),
  z.literal('NU'),
  z.literal('NZ'),
  z.literal('OM'),
  z.literal('PA'),
  z.literal('PE'),
  z.literal('PF'),
  z.literal('PG'),
  z.literal('PH'),
  z.literal('PK'),
  z.literal('PL'),
  z.literal('PM'),
  z.literal('PN'),
  z.literal('PR'),
  z.literal('PS'),
  z.literal('PT'),
  z.literal('PW'),
  z.literal('PY'),
  z.literal('QA'),
  z.literal('RE'),
  z.literal('RO'),
  z.literal('RS'),
  z.literal('RU'),
  z.literal('RW'),
  z.literal('SA'),
  z.literal('SB'),
  z.literal('SC'),
  z.literal('SD'),
  z.literal('SE'),
  z.literal('SG'),
  z.literal('SH'),
  z.literal('SI'),
  z.literal('SJ'),
  z.literal('SK'),
  z.literal('SL'),
  z.literal('SM'),
  z.literal('SN'),
  z.literal('SO'),
  z.literal('SR'),
  z.literal('SS'),
  z.literal('ST'),
  z.literal('SV'),
  z.literal('SX'),
  z.literal('SY'),
  z.literal('SZ'),
  z.literal('TC'),
  z.literal('TD'),
  z.literal('TF'),
  z.literal('TG'),
  z.literal('TH'),
  z.literal('TJ'),
  z.literal('TK'),
  z.literal('TL'),
  z.literal('TM'),
  z.literal('TN'),
  z.literal('TO'),
  z.literal('TR'),
  z.literal('TT'),
  z.literal('TV'),
  z.literal('TW'),
  z.literal('TZ'),
  z.literal('UA'),
  z.literal('UG'),
  z.literal('UM'),
  z.literal('US'),
  z.literal('UY'),
  z.literal('UZ'),
  z.literal('VA'),
  z.literal('VC'),
  z.literal('VE'),
  z.literal('VG'),
  z.literal('VI'),
  z.literal('VN'),
  z.literal('VU'),
  z.literal('WF'),
  z.literal('WS'),
  z.literal('YE'),
  z.literal('YT'),
  z.literal('ZA'),
  z.literal('ZM'),
  z.literal('ZW'),
])

export const itemCrawlerSchema = z.union([
  z.literal('google'),
  z.literal('msn'),
  z.literal('scirus'),
  z.literal('yahoo'),
  z.literal('iParadigms'),
])

export const crossmarkDomainExclusiveSchema = elementSchema.extend({
  name: z.literal('crossmark_domain_exclusive'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const crossmarkPolicySchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(6)
        .max(2048)
        .regex(/10\.[0-9]{4,9}\/.{1,200}/),
    }),
  ]),
})

export const doiTSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const crossmarkVersionSchema = elementSchema.extend({
  name: z.literal('crossmark_version'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const customMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('custom_metadata'),
  children: z.array(z.literal(ct.Program)),
})

export const cYearSchema = elementSchema.extend({
  name: z.literal('cYear'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const datasetDatasetTypeSchema = z.union([
  z.literal('record'),
  z.literal('collection'),
  z.literal('crossmark_policy'),
  z.literal('other'),
])

export const dateSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const datePrimitiveTypeSchema = z.string()

export const daySchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(2),
    }),
  ]),
})

export const xrefDaySchema = z.string().min(2).max(2)

export const degreeSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(255),
    }),
  ]),
})

export const degreePrimitiveTypeSchema = z.string().min(2).max(255)

export const depositorNameSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(130),
    }),
  ]),
})

export const depositorNamePrimitiveTypeSchema = z.string().min(1).max(130)

export const doiSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const doiPrimitiveTypeSchema = z.string()

export const doiBatchIdSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(4).max(100),
    }),
  ]),
})

export const doiBatchIdPrimitiveTypeSchema = z.string().min(4).max(100)

export const domainSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(4)
        .max(1024)
        .regex(/[A-Za-z0-9_]+([-.][A-Za-z0-9_]+)*\.[A-Za-z0-9_]+([-.][A-Za-z0-9_]+)*/),
    }),
  ]),
})

export const cmDomainSchema = z
  .string()
  .min(4)
  .max(1024)
  .regex(/[A-Za-z0-9_]+([-.][A-Za-z0-9_]+)*\.[A-Za-z0-9_]+([-.][A-Za-z0-9_]+)*/)

export const editionNumberSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(15),
    }),
  ]),
})

export const editionNumberPrimitiveTypeSchema = z.string().min(1).max(15)

export const elocationIdSchema = elementSchema.extend({
  name: z.literal('elocation_id'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const emailAddressSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(6).max(200),
    }),
  ]),
})

export const emailAddressPrimitiveTypeSchema = z.string().min(6).max(200)

export const endDaySchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(2),
    }),
  ]),
})

export const endMonthSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(2),
    }),
  ]),
})

export const xrefMonthSchema = z.string()

export const endYearSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(4).max(4),
    }),
  ]),
})

export const xrefYearSchema = z.string().min(4).max(4)

export const eventMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('event_metadata'),
  children: z.array(
    z.union([
      conferenceAcronymSchema,
      conferenceDateSchema,
      conferenceLocationSchema,
      conferenceNameSchema,
      conferenceNumberSchema,
      conferenceSponsorSchema,
      conferenceThemeSchema,
    ]),
  ),
})

export const explanationSchema = elementSchema.extend({
  name: z.literal('explanation'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const familySchema = elementSchema.extend({
  name: z.literal('family'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const stringSchema = z.string()

export const filterSchema = elementSchema.extend({
  name: z.literal('filter'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const firstPageSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(32),
    }),
  ]),
})

export const firstPagePrimitiveTypeSchema = z.string().min(1).max(32)

export const fullTitleSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const fullTitlePrimitiveTypeSchema = z.string().min(1).max(255)

export const givenNameSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(1)
        .max(60)
        .regex(/[^\d\?]*[^\?\s]+[^\d]*/),
    }),
  ]),
})

export const givenNamePrimitiveTypeSchema = z
  .string()
  .min(1)
  .max(60)
  .regex(/[^\d\?]*[^\?\s]+[^\d]*/)

export const groupLabelSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const cmAssertionGroupLabelSchema = z.string().min(2).max(150)

export const groupNameSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const cmAssertionGroupNameSchema = z.string().min(2).max(150)

export const groupTitleSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(1024),
    }),
  ]),
})

export const groupTitlePrimitiveTypeSchema = z.string().min(1).max(1024)

export const hrefSchema = elementSchema.extend({
  name: z.literal('href'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const identifierIdTypeSchema = z.union([
  z.literal('pii'),
  z.literal('sici'),
  z.literal('doi'),
  z.literal('dai'),
  z.literal('Z39.23'),
  z.literal('ISO-std-ref'),
  z.literal('std-designation'),
  z.literal('report-number'),
  z.literal('pmid'),
  z.literal('other'),
])

export const identifierSchema = identifierTSchema.extend({
  type: z.literal('element'),
  name: z.literal('identifier'),
  attributes: z.object({
    id_type: identifierIdTypeSchema,
  }),
})

export const institutionAcronymSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const institutionAcronymPrimitiveTypeSchema = z.string().min(1).max(255)

export const institutionDepartmentSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(255),
    }),
  ]),
})

export const institutionDepartmentPrimitiveTypeSchema = z.string().min(2).max(255)

export const institutionNameSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(1024),
    }),
  ]),
})

export const institutionNamePrimitiveTypeSchema = z.string().min(1).max(1024)

export const institutionPlaceSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(255),
    }),
  ]),
})

export const institutionPlacePrimitiveTypeSchema = z.string().min(2).max(255)

export const issueSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(32),
    }),
  ]),
})

export const issuePrimitiveTypeSchema = z.string().min(1).max(32)

export const itemNumberSchema = itemNumberTSchema.extend({
  type: z.literal('element'),
  name: z.literal('item_number'),
  attributes: z.object({
    item_number_type: z.string().optional(),
  }),
})

export const itemNumberTypeSchema = elementSchema.extend({
  name: z.literal('item_number_type'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const journalTitleSchema = elementSchema.extend({
  name: z.literal('journal_title'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const keySchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(128),
    }),
  ]),
})

export const keyPrimitiveTypeSchema = z.string()

export const labelSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const cmAssertionLabelSchema = z.string().min(2).max(150)

export const itemLabelSchema = z.string()

export const languageSchema = z.union([
  z.literal('aa'),
  z.literal('ab'),
  z.literal('ae'),
  z.literal('af'),
  z.literal('ak'),
  z.literal('am'),
  z.literal('an'),
  z.literal('ar'),
  z.literal('as'),
  z.literal('av'),
  z.literal('ay'),
  z.literal('az'),
  z.literal('ba'),
  z.literal('be'),
  z.literal('bg'),
  z.literal('bh'),
  z.literal('bi'),
  z.literal('bm'),
  z.literal('bn'),
  z.literal('bo'),
  z.literal('br'),
  z.literal('bs'),
  z.literal('ca'),
  z.literal('ce'),
  z.literal('ch'),
  z.literal('co'),
  z.literal('cr'),
  z.literal('cs'),
  z.literal('cu'),
  z.literal('cv'),
  z.literal('cy'),
  z.literal('da'),
  z.literal('de'),
  z.literal('dv'),
  z.literal('dz'),
  z.literal('ee'),
  z.literal('el'),
  z.literal('en'),
  z.literal('eo'),
  z.literal('es'),
  z.literal('et'),
  z.literal('eu'),
  z.literal('fa'),
  z.literal('ff'),
  z.literal('fi'),
  z.literal('fj'),
  z.literal('fo'),
  z.literal('fr'),
  z.literal('fy'),
  z.literal('ga'),
  z.literal('gd'),
  z.literal('gl'),
  z.literal('gn'),
  z.literal('gu'),
  z.literal('gv'),
  z.literal('ha'),
  z.literal('he'),
  z.literal('hi'),
  z.literal('ho'),
  z.literal('hr'),
  z.literal('ht'),
  z.literal('hu'),
  z.literal('hy'),
  z.literal('hz'),
  z.literal('ia'),
  z.literal('id'),
  z.literal('ie'),
  z.literal('ig'),
  z.literal('ii'),
  z.literal('ik'),
  z.literal('io'),
  z.literal('is'),
  z.literal('it'),
  z.literal('iu'),
  z.literal('ja'),
  z.literal('jw'),
  z.literal('ka'),
  z.literal('kg'),
  z.literal('ki'),
  z.literal('kj'),
  z.literal('kk'),
  z.literal('kl'),
  z.literal('km'),
  z.literal('kn'),
  z.literal('ko'),
  z.literal('kr'),
  z.literal('ks'),
  z.literal('ku'),
  z.literal('kv'),
  z.literal('kw'),
  z.literal('ky'),
  z.literal('la'),
  z.literal('lb'),
  z.literal('lg'),
  z.literal('li'),
  z.literal('ln'),
  z.literal('lo'),
  z.literal('lt'),
  z.literal('lu'),
  z.literal('lv'),
  z.literal('mg'),
  z.literal('mu'),
  z.literal('mi'),
  z.literal('mk'),
  z.literal('ml'),
  z.literal('mn'),
  z.literal('mr'),
  z.literal('ms'),
  z.literal('mt'),
  z.literal('my'),
  z.literal('na'),
  z.literal('nb'),
  z.literal('nd'),
  z.literal('ne'),
  z.literal('ng'),
  z.literal('nl'),
  z.literal('nn'),
  z.literal('no'),
  z.literal('nr'),
  z.literal('nv'),
  z.literal('ny'),
  z.literal('oc'),
  z.literal('oj'),
  z.literal('om'),
  z.literal('or'),
  z.literal('os'),
  z.literal('pa'),
  z.literal('pi'),
  z.literal('pl'),
  z.literal('ps'),
  z.literal('pt'),
  z.literal('qu'),
  z.literal('rm'),
  z.literal('rn'),
  z.literal('ro'),
  z.literal('ru'),
  z.literal('rw'),
  z.literal('sa'),
  z.literal('sc'),
  z.literal('sd'),
  z.literal('se'),
  z.literal('sg'),
  z.literal('si'),
  z.literal('sk'),
  z.literal('sl'),
  z.literal('sm'),
  z.literal('sn'),
  z.literal('so'),
  z.literal('sq'),
  z.literal('sr'),
  z.literal('ss'),
  z.literal('st'),
  z.literal('su'),
  z.literal('sv'),
  z.literal('sw'),
  z.literal('ta'),
  z.literal('te'),
  z.literal('tg'),
  z.literal('th'),
  z.literal('ti'),
  z.literal('tk'),
  z.literal('tl'),
  z.literal('tn'),
  z.literal('to'),
  z.literal('tr'),
  z.literal('ts'),
  z.literal('tt'),
  z.literal('tw'),
  z.literal('ty'),
  z.literal('ug'),
  z.literal('uk'),
  z.literal('ur'),
  z.literal('uz'),
  z.literal('ve'),
  z.literal('vi'),
  z.literal('vo'),
  z.literal('wa'),
  z.literal('wo'),
  z.literal('xh'),
  z.literal('yi'),
  z.literal('yo'),
  z.literal('za'),
  z.literal('zh'),
])

export const lastPageSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(32),
    }),
  ]),
})

export const lastPagePrimitiveTypeSchema = z.string().min(1).max(32)

export const levelSequenceNumberSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(1),
    }),
  ]),
})

export const contentItemLevelSequenceNumberSchema = z.string()

export const itemLinkHeaderRelationshipSchema = z.literal('dul')

export const dateTMediaTypeSchema = z.union([
  z.literal('online'),
  z.literal('print'),
  z.literal('other'),
])

export const mediaTypeSchema = z.union([z.literal('print'), z.literal('electronic')])

export const mimeTypeSchema = z.union([
  z.literal('text/css'),
  z.literal('text/csv'),
  z.literal('text/enriched'),
  z.literal('text/html'),
  z.literal('text/plain'),
  z.literal('text/richtext'),
  z.literal('text/rtf'),
  z.literal('text/sgml'),
  z.literal('text/tab-separated-values'),
  z.literal('text/xml'),
  z.literal('text/xml-external-parsed-entity'),
  z.literal('multipart/mixed'),
  z.literal('multipart/alternative'),
  z.literal('multipart/digest'),
  z.literal('multipart/parallel'),
  z.literal('multipart/appledouble'),
  z.literal('multipart/header-set'),
  z.literal('multipart/form-data'),
  z.literal('multipart/report'),
  z.literal('multipart/voice-message'),
  z.literal('multipart/signed'),
  z.literal('multipart/encrypted'),
  z.literal('multipart/byteranges'),
  z.literal('application/eps'),
  z.literal('application/epub+zip'),
  z.literal('application/octet-stream'),
  z.literal('application/postscript'),
  z.literal('application/rtf'),
  z.literal('application/applefile'),
  z.literal('application/mac-binhex40'),
  z.literal('application/wordperfect5.1'),
  z.literal('application/pdf'),
  z.literal('application/x-gzip'),
  z.literal('application/zip'),
  z.literal('application/gzip'),
  z.literal('application/macwriteii'),
  z.literal('application/msword'),
  z.literal('application/sgml'),
  z.literal('application/cals-1840'),
  z.literal('application/pgp-encrypted'),
  z.literal('application/pgp-signature'),
  z.literal('application/pgp-keys'),
  z.literal('application/sgml-open-catalog'),
  z.literal('application/rc'),
  z.literal('application/xml'),
  z.literal('application/xml-external-parsed-entity'),
  z.literal('application/xml-dtd'),
  z.literal('application/batch-SMTP'),
  z.literal('application/ipp'),
  z.literal('application/ocsp-request'),
  z.literal('application/ocsp-response'),
  z.literal('application/vnd.wolfram.mathematica'),
  z.literal('application/vnd.wolfram.mathematica.package'),
  z.literal('application/vnd.wolfram.player'),
  z.literal('application/vnd.oasis.opendocument.text'),
  z.literal('application/vnd.oasis.opendocument.presentation'),
  z.literal('application/vnd.oasis.opendocument.spreadsheet'),
  z.literal('application/vnd.ms-asf'),
  z.literal('application/vnd.ms-excel'),
  z.literal('application/vnd.ms-powerpoint'),
  z.literal('application/vnd.openxmlformats-officedocument.presentationml.presentation'),
  z.literal('application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'),
  z.literal('application/vnd.openxmlformats-officedocument.wordprocessingml.document'),
  z.literal('application/epub+zip'),
  z.literal('application/regex.clinical-trial-number'),
  z.literal('image/fits'),
  z.literal('image/jpeg'),
  z.literal('image/gif'),
  z.literal('image/ief'),
  z.literal('image/g3fax'),
  z.literal('image/tiff'),
  z.literal('image/Graphics-Metafile'),
  z.literal('image/png'),
  z.literal('audio/basic'),
  z.literal('audio/32kadpcm'),
  z.literal('audio/mpeg'),
  z.literal('audio/parityfec'),
  z.literal('audio/MP4A-LATM'),
  z.literal('audio/mpa-robust'),
  z.literal('video/x-ms-wmv'),
  z.literal('video/avi'),
  z.literal('video/mpeg'),
  z.literal('video/quicktime'),
  z.literal('video/pointer'),
  z.literal('video/parityfec'),
  z.literal('video/MP4V-ES'),
  z.literal('video/mp4'),
  z.literal('chemical/x-alchemy'),
  z.literal('chemical/x-cache-csf'),
  z.literal('chemical/x-cactvs-binary'),
  z.literal('chemical/x-cactvs-binary'),
  z.literal('chemical/x-cactvs-binary'),
  z.literal('chemical/x-cdx'),
  z.literal('chemical/x-cerius'),
  z.literal('chemical/x-chemdraw'),
  z.literal('chemical/x-cif'),
  z.literal('chemical/x-mmcif'),
  z.literal('chemical/x-chem3d'),
  z.literal('chemical/x-cmdf'),
  z.literal('chemical/x-compass'),
  z.literal('chemical/x-crossfire'),
  z.literal('chemical/x-cml'),
  z.literal('chemical/x-csml'),
  z.literal('chemical/x-ctx'),
  z.literal('chemical/x-cxf'),
  z.literal('chemical/x-daylight-smiles'),
  z.literal('chemical/x-embl-dl-nucleotide'),
  z.literal('chemical/x-galactic-spc'),
  z.literal('chemical/x-gamess-input'),
  z.literal('chemical/x-gaussian-input'),
  z.literal('chemical/x-gaussian-checkpoint'),
  z.literal('chemical/x-gaussian-cube'),
  z.literal('chemical/x-gcg8-sequence'),
  z.literal('chemical/x-genbank'),
  z.literal('chemical/x-isostar'),
  z.literal('chemical/x-jcamp-dx'),
  z.literal('chemical/x-kinemage'),
  z.literal('chemical/x-macmolecule'),
  z.literal('chemical/x-macromodel-input'),
  z.literal('chemical/x-mdl-molfile'),
  z.literal('chemical/x-mdl-rdfile'),
  z.literal('chemical/x-mdl-rxnfile'),
  z.literal('chemical/x-mdl-sdfile'),
  z.literal('chemical/x-mdl-tgf'),
  z.literal('chemical/x-mif'),
  z.literal('chemical/x-mol2'),
  z.literal('chemical/x-molconn-Z'),
  z.literal('chemical/x-mopac-input'),
  z.literal('chemical/x-mopac-graph'),
  z.literal('chemical/x-ncbi-asn1'),
  z.literal('chemical/x-ncbi-asn1-binary'),
  z.literal('chemical/x-pdb'),
  z.literal('chemical/x-swissprot'),
  z.literal('chemical/x-vamas-iso14976'),
  z.literal('chemical/x-vmd'),
  z.literal('chemical/x-xtel'),
  z.literal('chemical/x-xyz'),
  z.literal('model/stl'),
  z.literal('model/x.stl-binary'),
  z.literal('model/x.stl-ascii'),
  z.literal('model/vrml'),
  z.literal('audio/x-wav'),
  z.literal('video/x-flv'),
  z.literal('Data/spcvue.htm'),
])

export const monthSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(2),
    }),
  ]),
})

export const collectionMultiResolutionSchema = z.union([z.literal('lock'), z.literal('unlock')])

export const archiveNameSchema = z.union([
  z.literal('CLOCKSS'),
  z.literal('LOCKSS'),
  z.literal('Portico'),
  z.literal('KB'),
  z.literal('Internet Archive'),
  z.literal('DWT'),
])

export const cmAssertionNameSchema = z.string().min(2).max(150)

export const nameNameStyleSchema = z.union([
  z.literal('western'),
  z.literal('eastern'),
  z.literal('islensk'),
  z.literal('given-only'),
])

export const stringNameNameStyleSchema = z.union([
  z.literal('western'),
  z.literal('eastern'),
  z.literal('islensk'),
  z.literal('given-only'),
])

export const nameStyleSchema = z.union([
  z.literal('western'),
  z.literal('eastern'),
  z.literal('islensk'),
  z.literal('given-only'),
])

export const orcidSchema = orcidTSchema.extend({
  type: z.literal('element'),
  name: z.literal('ORCID'),
  attributes: z.object({
    authenticated: z.string(),
  }),
})

export const orderSchema = elementSchema.extend({
  name: z.literal('order'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const originalLanguageTitleSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('original_language_title'),
  attributes: z.object({
    language: languageSchema.optional(),
  }),
  children: z.tuple([]),
})

export const otherPagesSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(100),
    }),
  ]),
})

export const otherPagesPrimitiveTypeSchema = z.string().min(1).max(100)

export const pagesSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('pages'),
  children: z.array(z.union([firstPageSchema, lastPageSchema, otherPagesSchema])),
})

export const parentDoiSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(6).max(2048),
    }),
  ]),
})

export const saComponentParentDoiSchema = z.string()

export const componentParentRelationSchema = z.union([
  z.literal('isPartOf'),
  z.literal('isReferencedBy'),
  z.literal('isRequiredBy'),
  z.literal('isTranslationOf'),
])

export const partNumberSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(15),
    }),
  ]),
})

export const partNumberPrimitiveTypeSchema = z.string().min(1).max(15)

export const prefixSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('prefix'),
  attributes: z.object({
    language: languageSchema.optional(),
  }),
  children: z.tuple([]),
})

export const proceedingsSubjectSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const proceedingsSubjectPrimitiveTypeSchema = z.string().min(1).max(255)

export const proceedingsTitleSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(511),
    }),
  ]),
})

export const proceedingsTitlePrimitiveTypeSchema = z.string().min(1).max(511)

export const collectionPropertySchema = z.union([
  z.literal('list-based'),
  z.literal('country-based'),
  z.literal('crawler-based'),
  z.literal('text-mining'),
  z.literal('unspecified'),
  z.literal('syndication'),
  z.literal('link-header'),
])

export const publicationSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('publication'),
  children: z.array(fullTitleSchema),
})

export const standardMetadataPublicationStatusSchema = z.union([
  z.literal('released'),
  z.literal('withdrawn'),
])

export const publicationTypeSchema = z.union([
  z.literal('abstract_only'),
  z.literal('full_text'),
  z.literal('bibliographic_record'),
])

export const publisherItemSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('publisher_item'),
  children: z.array(z.union([identifierSchema, itemNumberSchema])),
})

export const publisherNameSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const publisherNamePrimitiveTypeSchema = z.string().min(1).max(255)

export const publisherPlaceSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(255),
    }),
  ]),
})

export const publisherPlacePrimitiveTypeSchema = z.string().min(2).max(255)

export const noisbnReasonSchema = z.union([
  z.literal('archive_volume'),
  z.literal('monograph'),
  z.literal('simple_series'),
])

export const stdAltAsPublishedReasonSchema = z.string()

export const peerReviewRecommendationSchema = z.union([
  z.literal('major-revision'),
  z.literal('minor-revision'),
  z.literal('reject'),
  z.literal('reject-with-resubmit'),
  z.literal('accept'),
  z.literal('accept-with-reservation'),
])

export const referenceDistributionOptsSchema = z.union([
  z.literal('none'),
  z.literal('query'),
  z.literal('any'),
])

export const regAgencySchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const componentRegAgencySchema = z.string()

export const registrantSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(255),
    }),
  ]),
})

export const registrantPrimitiveTypeSchema = z.string().min(1).max(255)

export const resourceSchema = resourceTSchema.extend({
  type: z.literal('element'),
  name: z.literal('resource'),
  attributes: z.object({
    content_version: resourceContentVersionSchema,
    mime_type: mimeTypeSchema.optional(),
  }),
})

export const revisionRoundSchema = elementSchema.extend({
  name: z.literal('revision-round'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const runningNumberSchema = elementSchema.extend({
  name: z.literal('running_number'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const scnPolicyRefSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(1)
        .max(2048)
        .regex(/([hH][tT][tT][pP]|[hH][tT][tT][pP][sS]|[fF][tT][pP]):\/\/.*/),
    }),
  ]),
})

export const scnPolicyRefPrimitiveTypeSchema = z
  .string()
  .min(1)
  .max(2048)
  .regex(/([hH][tT][tT][pP]|[hH][tT][tT][pP][sS]|[fF][tT][pP]):\/\/.*/)

export const scnPolicySetSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('scn_policy_set'),
  attributes: z.object({
    start_date: z.string().optional(),
  }),
  children: z.array(scnPolicyRefSchema),
})

export const sequenceSchema = z.union([z.literal('first'), z.literal('additional')])

export const seriesNumberSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(15),
    }),
  ]),
})

export const seriesNumberPrimitiveTypeSchema = z.string().min(1).max(15)

export const seriesTitleSchema = elementSchema.extend({
  name: z.literal('series_title'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const setSchema = elementSchema.extend({
  name: z.literal('set'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const specialNumberingSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(15),
    }),
  ]),
})

export const specialNumberingPrimitiveTypeSchema = z.string().min(1).max(15)

export const peerReviewStageSchema = z.union([
  z.literal('pre-publication'),
  z.literal('post-publication'),
])

export const standardsBodySchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('standards_body'),
  children: z.tuple([]),
})

export const startDateSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const startDaySchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(2),
    }),
  ]),
})

export const startMonthSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(2),
    }),
  ]),
})

export const startYearSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(4).max(4),
    }),
  ]),
})

export const stdAdoptedFromSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const stdDesignatorvalueTSchema = z.string().min(2).max(150)

export const stdAltScriptSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const stdDesignatorSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const stdDesignatorTSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.string(),
})

export const stdRevisionOfSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const stdSetDesignatorSchema = stdDesignatorTSchema.extend({
  type: z.literal('element'),
  name: z.literal('std_set_designator'),
  attributes: z.object({
    family: z.string(),
  }),
})

export const stdSupersedesSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const stdUndatedDesignatorSchema = stdDesignatorTSchema.extend({
  type: z.literal('element'),
  name: z.literal('std_undated_designator'),
  attributes: z.object({
    family: z.string(),
    set: z.string(),
  }),
})

export const stdVariantFormSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(2).max(150),
    }),
  ]),
})

export const subtitleSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('subtitle'),
  children: z.tuple([]),
})

export const suffixSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(10),
    }),
  ]),
})

export const suffixPrimitiveTypeSchema = z.string().min(1).max(10)

export const surnameSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z
        .string()
        .min(1)
        .max(60)
        .regex(/[^\d\?]*[^\?\s]+[^\d]*/),
    }),
  ]),
})

export const surnamePrimitiveTypeSchema = z
  .string()
  .min(1)
  .max(60)
  .regex(/[^\d\?]*[^\?\s]+[^\d]*/)

export const timestampSchema = elementSchema.extend({
  name: z.literal('timestamp'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const titleSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('title'),
  children: z.tuple([]),
})

export const titlesSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('titles'),
  children: z.array(z.union([originalLanguageTitleSchema, subtitleSchema, titleSchema])),
})

export const institutionIdTypeSchema = z.union([
  z.literal('ror'),
  z.literal('isni'),
  z.literal('wikidata'),
])

export const cmUpdateTypeSchema = z.union([
  z.literal('addendum'),
  z.literal('clarification'),
  z.literal('correction'),
  z.literal('corrigendum'),
  z.literal('erratum'),
  z.literal('expression_of_concern'),
  z.literal('new_edition'),
  z.literal('new_version'),
  z.literal('partial_retraction'),
  z.literal('removal'),
  z.literal('retraction'),
  z.literal('withdrawal'),
])

export const peerReviewTypeSchema = z.union([
  z.literal('referee-report'),
  z.literal('editor-report'),
  z.literal('author-comment'),
  z.literal('community-comment'),
  z.literal('manuscript'),
  z.literal('aggregate'),
  z.literal('recommendation'),
])

export const postedContentTypeSchema = z.union([
  z.literal('preprint'),
  z.literal('working_paper'),
  z.literal('letter'),
  z.literal('dissertation'),
  z.literal('report'),
  z.literal('review'),
  z.literal('other'),
])

export const undatedSchema = elementSchema.extend({
  name: z.literal('undated'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const unstructuredCitationSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('unstructured_citation'),
  children: z.tuple([]),
})

export const updateSchema = doiTSchema.extend({
  type: z.literal('element'),
  name: z.literal('update'),
  attributes: z.object({
    date: z.string(),
    type: cmUpdateTypeSchema,
  }),
})

export const updatesSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('updates'),
  children: z.array(updateSchema),
})

export const versionSchema = elementSchema.extend({
  name: z.literal('version'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const volumeSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(1).max(32),
    }),
  ]),
})

export const volumePrimitiveTypeSchema = z.string().min(1).max(32)

export const volumeTitleSchema = elementSchema.extend({
  name: z.literal('volume_title'),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string(),
    }),
  ]),
})

export const yearSchema = elementSchema.extend({
  name: z.string(),
  children: z.tuple([
    z.object({
      type: z.literal('text'),
      value: z.string().min(4).max(4),
    }),
  ]),
})

export const dateTSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.string(),
  attributes: z.object({
    media_type: dateTMediaTypeSchema,
  }),
  children: z.array(z.union([daySchema, monthSchema, yearSchema])),
})

export const acceptanceDateSchema = dateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('acceptance_date'),
})

export const approvalDateSchema = dateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('approval_date'),
})

export const archiveSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('archive'),
  attributes: z.object({
    name: archiveNameSchema,
  }),
  children: z.tuple([]),
})

export const archiveLocationsSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('archive_locations'),
  children: z.array(archiveSchema),
})

export const competingInterestStatementSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('competing_interest_statement'),
  attributes: z.object({
    language: languageSchema.optional(),
  }),
  children: z.tuple([]),
})

export const contentDateSchema = dateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('content_date'),
})

export const creationDateSchema = dateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('creation_date'),
})

export const crossmarkDomainSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('crossmark_domain'),
  children: z.array(z.union([domainSchema, filterSchema])),
})

export const crossmarkDomainsSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('crossmark_domains'),
  children: z.array(crossmarkDomainSchema),
})

export const degreesSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('degrees'),
  attributes: z.object({
    language: languageSchema.optional(),
  }),
  children: z.tuple([]),
})

export const depositorSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('depositor'),
  children: z.array(z.union([depositorNameSchema, emailAddressSchema])),
})

export const descriptionSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('description'),
  attributes: z.object({
    language: languageSchema.optional(),
  }),
  children: z.tuple([]),
})

export const designatorsSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('designators'),
  children: z.array(z.union([stdAdoptedFromSchema, stdRevisionOfSchema, stdSupersedesSchema])),
})

export const formatSchema = formatTSchema.extend({
  type: z.literal('element'),
  name: z.literal('format'),
  attributes: z.object({
    mime_type: mimeTypeSchema.optional(),
  }),
})

export const headSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('head'),
  children: z.array(
    z.union([depositorSchema, doiBatchIdSchema, registrantSchema, timestampSchema]),
  ),
})

export const institutionIdSchema = pidSchema.extend({
  type: z.literal('element'),
  name: z.literal('institution_id'),
  attributes: z.object({
    type: institutionIdTypeSchema,
  }),
})

export const intentStatementSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('intent_statement'),
  attributes: z.object({
    language: languageSchema.optional(),
  }),
  children: z.array(z.union([aSchema, xrefFacesSchema, xrefFacesSchema, xrefFacesSchema])),
})

export const isbnSchema = isbnTSchema.extend({
  type: z.literal('element'),
  name: z.literal('isbn'),
  attributes: z.object({
    media_type: mediaTypeSchema,
  }),
})

export const issnSchema = issnTSchema.extend({
  type: z.literal('element'),
  name: z.literal('issn'),
  attributes: z.object({
    media_type: mediaTypeSchema,
  }),
})

export const itemSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('item'),
  attributes: z.object({
    country: itemCountrySchema.optional(),
    crawler: itemCrawlerSchema.optional(),
    label: z.string().optional(),
    link_header_relationship: itemLinkHeaderRelationshipSchema,
  }),
  children: z.array(z.union([doiSchema, resourceSchema])),
})

export const nameSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('name'),
  attributes: z.object({
    language: languageSchema.optional(),
    nameStyle: nameNameStyleSchema,
  }),
  children: z.array(z.union([givenNameSchema, prefixSchema, suffixSchema])),
})

export const noisbnSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('noisbn'),
  attributes: z.object({
    reason: noisbnReasonSchema,
  }),
  children: z.tuple([]),
})

export const organizationSchema = organizationTSchema.extend({
  type: z.literal('element'),
  name: z.literal('organization'),
  attributes: z.object({
    contributor_role: contributorRoleSchema,
    language: languageSchema.optional(),
    nameStyle: nameStyleSchema.optional(),
    sequence: sequenceSchema,
  }),
})

export const postedDateSchema = dateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('posted_date'),
})

export const publicationDateSchema = dateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('publication_date'),
})

export const publisherSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('publisher'),
  children: z.array(z.union([publisherNameSchema, publisherPlaceSchema])),
})

export const reviewDateSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('review_date'),
  children: z.array(z.union([daySchema, monthSchema, yearSchema])),
})

export const scnPoliciesSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('scn_policies'),
  children: z.array(scnPolicySetSchema),
})

export const stdAltAsPublishedSchema = stdDesignatorTSchema.extend({
  type: z.literal('element'),
  name: z.literal('std_alt_as_published'),
  attributes: z.object({
    approvedMonth: z.string().optional(),
    approvedYear: z.string(),
    Reason: stdAltAsPublishedReasonSchema,
  }),
})

export const stdAsPublishedSchema = stdDesignatorTSchema.extend({
  type: z.literal('element'),
  name: z.literal('std_as_published'),
  attributes: z.object({
    family: z.string(),
    set: z.string(),
    undated: z.string(),
  }),
})

export const stringNameSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('string-name'),
  attributes: z.object({
    language: languageSchema.optional(),
    nameStyle: stringNameNameStyleSchema,
  }),
  children: z.array(
    z.union([degreesSchema, givenNameSchema, prefixSchema, suffixSchema, surnameSchema]),
  ),
})

export const updateDateSchema = dateTSchema.extend({
  type: z.literal('element'),
  name: z.literal('update_date'),
})

export const altNameSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('alt-name'),
  children: z.array(z.union([nameSchema, stringNameSchema])),
})

export const collectionSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('collection'),
  attributes: z.object({
    multiResolution: collectionMultiResolutionSchema,
    property: collectionPropertySchema,
  }),
  children: z.array(itemSchema),
})

export const crossmarkSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('crossmark'),
  children: z.array(
    z.union([
      crossmarkDomainExclusiveSchema,
      crossmarkDomainsSchema,
      crossmarkPolicySchema,
      crossmarkVersionSchema,
      customMetadataSchema,
      updatesSchema,
    ]),
  ),
})

export const databaseDateSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('database_date'),
  children: z.array(z.union([creationDateSchema, publicationDateSchema, updateDateSchema])),
})

export const doiDataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('doi_data'),
  children: z.array(z.union([collectionSchema, doiSchema, resourceSchema, timestampSchema])),
})

export const institutionSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('institution'),
  children: z.array(
    z.union([
      institutionAcronymSchema,
      institutionDepartmentSchema,
      institutionIdSchema,
      institutionPlaceSchema,
    ]),
  ),
})

export const journalMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('journal_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      abbrevTitleSchema,
      archiveLocationsSchema,
      codenSchema,
      doiDataSchema,
      fullTitleSchema,
      issnSchema,
    ]),
  ),
})

export const journalVolumeSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('journal_volume'),
  children: z.array(
    z.union([archiveLocationsSchema, doiDataSchema, publisherItemSchema, volumeSchema]),
  ),
})

export const proceedingsMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('proceedings_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      archiveLocationsSchema,
      doiDataSchema,
      isbnSchema,
      noisbnSchema,
      proceedingsSubjectSchema,
      proceedingsTitleSchema,
      publicationDateSchema,
      publisherSchema,
      publisherItemSchema,
    ]),
  ),
})

export const affiliationsSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('affiliations'),
  children: z.array(institutionSchema),
})

export const anonymousSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('anonymous'),
  attributes: z.object({
    contributor_role: contributorRoleSchema,
    language: languageSchema.optional(),
    nameStyle: nameStyleSchema.optional(),
    sequence: sequenceSchema,
  }),
  children: z.array(affiliationsSchema),
})

export const personNameSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('person_name'),
  attributes: z.object({
    contributor_role: contributorRoleSchema,
    language: languageSchema.optional(),
    nameStyle: nameStyleSchema.optional(),
    sequence: sequenceSchema,
  }),
  children: z.array(
    z.union([
      affiliationsSchema,
      altNameSchema,
      givenNameSchema,
      orcidSchema,
      suffixSchema,
      surnameSchema,
    ]),
  ),
})

export const contributorsSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('contributors'),
  children: z.array(z.union([anonymousSchema, organizationSchema, personNameSchema])),
})

export const databaseMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('database_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      archiveLocationsSchema,
      contributorsSchema,
      databaseDateSchema,
      descriptionSchema,
      doiDataSchema,
      institutionSchema,
      z.literal(rel.Program),
      publisherSchema,
      publisherItemSchema,
      titlesSchema,
    ]),
  ),
})

export const journalIssueSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('journal_issue'),
  children: z.array(
    z.union([
      archiveLocationsSchema,
      contributorsSchema,
      doiDataSchema,
      issueSchema,
      journalVolumeSchema,
      publicationDateSchema,
      specialNumberingSchema,
      titlesSchema,
    ]),
  ),
})

export const peerReviewSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('peer_review'),
  attributes: z.object({
    language: languageSchema.optional(),
    recommendation: peerReviewRecommendationSchema.optional(),
    revisionRound: z.string().optional(),
    stage: peerReviewStageSchema.optional(),
    type: peerReviewTypeSchema.optional(),
  }),
  children: z.array(
    z.union([
      competingInterestStatementSchema,
      contributorsSchema,
      doiDataSchema,
      institutionSchema,
      z.literal(ai.Program),
      reviewDateSchema,
      runningNumberSchema,
      scnPoliciesSchema,
      titlesSchema,
    ]),
  ),
})

export const pendingPublicationSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('pending_publication'),
  attributes: z.object({
    language: languageSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      acceptanceDateSchema,
      contributorsSchema,
      crossmarkSchema,
      doiSchema,
      institutionSchema,
      intentStatementSchema,
      itemNumberSchema,
      z.literal(rel.Program),
      publicationSchema,
      titlesSchema,
    ]),
  ),
})

export const postedContentSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('posted_content'),
  attributes: z.object({
    language: languageSchema.optional(),
    type: postedContentTypeSchema,
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      acceptanceDateSchema,
      citationListSchema,
      contributorsSchema,
      doiDataSchema,
      groupTitleSchema,
      institutionSchema,
      itemNumberSchema,
      postedDateSchema,
      z.literal(fr.Program),
      scnPoliciesSchema,
      titlesSchema,
    ]),
  ),
})

export const reportPaperMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('report-paper_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      approvalDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      contractNumberSchema,
      contributorsSchema,
      crossmarkSchema,
      doiDataSchema,
      editionNumberSchema,
      institutionSchema,
      isbnSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherSchema,
      publisherItemSchema,
      scnPoliciesSchema,
      titlesSchema,
    ]),
  ),
})

export const seriesMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('series_metadata'),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      archiveLocationsSchema,
      codenSchema,
      contributorsSchema,
      crossmarkSchema,
      doiDataSchema,
      issnSchema,
      publisherItemSchema,
      seriesNumberSchema,
      titlesSchema,
    ]),
  ),
})

export const setMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('set_metadata'),
  children: z.array(
    z.union([
      archiveLocationsSchema,
      contributorsSchema,
      doiDataSchema,
      isbnSchema,
      noisbnSchema,
      partNumberSchema,
      publisherItemSchema,
      titlesSchema,
    ]),
  ),
})

export const standardMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('standard_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    publication_status: standardMetadataPublicationStatusSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      approvalDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      contributorsSchema,
      crossmarkSchema,
      designatorsSchema,
      doiDataSchema,
      editionNumberSchema,
      isbnSchema,
      z.literal(rel.Program),
      publisherSchema,
      publisherItemSchema,
      standardsBodySchema,
      titlesSchema,
    ]),
  ),
})

export const bookMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('book_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      acceptanceDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      contributorsSchema,
      crossmarkSchema,
      doiDataSchema,
      editionNumberSchema,
      isbnSchema,
      noisbnSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherSchema,
      publisherItemSchema,
      titlesSchema,
    ]),
  ),
})

export const bookSeriesMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('book_series_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      archiveLocationsSchema,
      citationListSchema,
      crossmarkSchema,
      doiDataSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherSchema,
      publisherItemSchema,
      seriesMetadataSchema,
    ]),
  ),
})

export const bookSetMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('book_set_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      archiveLocationsSchema,
      citationListSchema,
      contributorsSchema,
      crossmarkSchema,
      doiDataSchema,
      editionNumberSchema,
      isbnSchema,
      noisbnSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherSchema,
      publisherItemSchema,
      setMetadataSchema,
      volumeSchema,
    ]),
  ),
})

export const componentSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('component'),
  attributes: z.object({
    component_size: z.string(),
    language: languageSchema.optional(),
    parent_relation: componentParentRelationSchema,
    regAgency: z.string().optional(),
  }),
  children: z.array(
    z.union([
      contributorsSchema,
      descriptionSchema,
      doiSchema,
      doiDataSchema,
      formatSchema,
      z.literal(ai.Program),
      publicationDateSchema,
      titlesSchema,
    ]),
  ),
})

export const componentListSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('component_list'),
  children: z.array(componentSchema),
})

export const conferencePaperSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('conference_paper'),
  attributes: z.object({
    language: languageSchema.optional(),
    publication_type: publicationTypeSchema,
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      acceptanceDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      componentListSchema,
      contributorsSchema,
      crossmarkSchema,
      doiDataSchema,
      pagesSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherItemSchema,
      scnPoliciesSchema,
      titlesSchema,
    ]),
  ),
})

export const contentItemSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('content_item'),
  attributes: z.object({
    component_type: contentItemComponentTypeSchema,
    language: languageSchema.optional(),
    level_sequence_number: z.string(),
    publication_type: publicationTypeSchema,
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      acceptanceDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      componentListSchema,
      componentNumberSchema,
      contributorsSchema,
      crossmarkSchema,
      doiDataSchema,
      pagesSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherItemSchema,
      scnPoliciesSchema,
      titlesSchema,
    ]),
  ),
})

export const datasetSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('dataset'),
  attributes: z.object({
    dataset_type: datasetDatasetTypeSchema,
  }),
  children: z.array(
    z.union([
      archiveLocationsSchema,
      citationListSchema,
      componentListSchema,
      contributorsSchema,
      crossmarkSchema,
      databaseDateSchema,
      descriptionSchema,
      doiDataSchema,
      formatSchema,
      z.literal(rel.Program),
      publisherItemSchema,
      titlesSchema,
    ]),
  ),
})

export const dissertationSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('dissertation'),
  attributes: z.object({
    language: languageSchema.optional(),
    publication_type: publicationTypeSchema,
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      approvalDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      componentListSchema,
      contributorsSchema,
      crossmarkSchema,
      degreeSchema,
      doiDataSchema,
      institutionSchema,
      isbnSchema,
      personNameSchema,
      z.literal(rel.Program),
      publisherItemSchema,
      scnPoliciesSchema,
      titlesSchema,
    ]),
  ),
})

export const journalArticleSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('journal_article'),
  attributes: z.object({
    language: languageSchema.optional(),
    publication_type: publicationTypeSchema,
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      z.literal(jats.Abstract),
      acceptanceDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      componentListSchema,
      contributorsSchema,
      crossmarkSchema,
      doiDataSchema,
      pagesSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherItemSchema,
      scnPoliciesSchema,
      titlesSchema,
    ]),
  ),
})

export const proceedingsSeriesMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('proceedings_series_metadata'),
  attributes: z.object({
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([archiveLocationsSchema, doiDataSchema, publisherItemSchema, seriesMetadataSchema]),
  ),
})

export const reportPaperSeriesMetadataSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('report-paper_series_metadata'),
  attributes: z.object({
    language: languageSchema.optional(),
    reference_distribution_opts: referenceDistributionOptsSchema.optional(),
  }),
  children: z.array(
    z.union([
      approvalDateSchema,
      archiveLocationsSchema,
      citationListSchema,
      contractNumberSchema,
      contributorsSchema,
      doiDataSchema,
      editionNumberSchema,
      institutionSchema,
      isbnSchema,
      z.literal(rel.Program),
      publicationDateSchema,
      publisherSchema,
      publisherItemSchema,
      seriesMetadataSchema,
      volumeSchema,
    ]),
  ),
})

export const saComponentSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('sa_component'),
  attributes: z.object({
    parent_doi: z.string(),
  }),
  children: z.array(componentListSchema),
})

export const standardSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('standard'),
  attributes: z.object({
    publication_type: publicationTypeSchema,
  }),
  children: z.array(z.union([componentListSchema, contentItemSchema, standardMetadataSchema])),
})

export const bookSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('book'),
  attributes: z.object({
    book_type: bookBookTypeSchema,
  }),
  children: z.array(
    z.union([
      bookMetadataSchema,
      bookSeriesMetadataSchema,
      bookSetMetadataSchema,
      contentItemSchema,
    ]),
  ),
})

export const conferenceSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('conference'),
  children: z.array(
    z.union([
      conferencePaperSchema,
      contributorsSchema,
      eventMetadataSchema,
      proceedingsMetadataSchema,
      proceedingsSeriesMetadataSchema,
    ]),
  ),
})

export const databaseSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('database'),
  children: z.array(z.union([componentListSchema, databaseMetadataSchema, datasetSchema])),
})

export const journalSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('journal'),
  children: z.array(z.union([journalArticleSchema, journalIssueSchema, journalMetadataSchema])),
})

export const reportPaperSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('report-paper'),
  attributes: z.object({
    publication_type: publicationTypeSchema,
  }),
  children: z.array(
    z.union([
      componentListSchema,
      contentItemSchema,
      reportPaperMetadataSchema,
      reportPaperSeriesMetadataSchema,
    ]),
  ),
})

export const bodySchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('body'),
  children: z.array(
    z.union([
      bookSchema,
      conferenceSchema,
      databaseSchema,
      dissertationSchema,
      journalSchema,
      peerReviewSchema,
      pendingPublicationSchema,
      postedContentSchema,
      reportPaperSchema,
      saComponentSchema,
      standardSchema,
    ]),
  ),
})

export const doiBatchSchema = elementSchema.extend({
  type: z.literal('element'),
  name: z.literal('doi_batch'),
  attributes: z.object({
    version: z.string(),
  }),
  children: z.array(z.union([bodySchema, headSchema])),
})