@polintpro/proposit-core 0.8.4 → 0.8.6

package/dist/extensions/ieee/references.js

@@ -1,6 +1,7 @@
 // IEEE Citation Reference Schemas
 // https://journals.ieeeauthorcenter.ieee.org/wp-content/uploads/sites/7/IEEE_Reference_Guide.pdf
 import Type, {} from "typebox";
+import { EncodableDate } from "../../lib/schemata/shared.js";
 // ---------------------------------------------------------------------------
 // Reference type discriminator
 // ---------------------------------------------------------------------------
@@ -46,111 +47,277 @@ const BaseReferenceSchema = Type.Object({
     type: ReferenceTypeSchema,
 });
 // ---------------------------------------------------------------------------
+// Structured author name
+// ---------------------------------------------------------------------------
+export const AuthorSchema = Type.Object({
+    givenNames: Type.String({
+        minLength: 1,
+        description: "Full given/first names (e.g. Jane Marie)",
+    }),
+    familyName: Type.String({ minLength: 1, description: "Family/last name" }),
+    suffix: Type.Optional(Type.String({
+        minLength: 1,
+        description: "Name suffix (Jr., Sr., III, etc.)",
+    })),
+});
+// ---------------------------------------------------------------------------
 // Textual sources
 // ---------------------------------------------------------------------------
 export const BookReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Book"),
-        title: Type.String(),
-        year: Type.String(),
-        authors: Type.Array(Type.String()),
-        edition: Type.Optional(Type.String()),
-        publisher: Type.String(),
-        location: Type.Optional(Type.String()),
-        isbn: Type.Optional(Type.String()),
+        title: Type.String({ minLength: 1, description: "Book title" }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        edition: Type.Optional(Type.String({ minLength: 1, description: "Edition identifier" })),
+        publisher: Type.String({
+            minLength: 1,
+            description: "Publisher name",
+        }),
+        location: Type.Optional(Type.String({
+            minLength: 1,
+            description: "Publication location",
+        })),
+        isbn: Type.Optional(Type.String({
+            pattern: "^(?:\\d{9}[\\dX]|\\d{13})$",
+            description: "ISBN-10 or ISBN-13 (digits only)",
+        })),
     }),
 ]);
 export const WebsiteReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Website"),
-        authors: Type.Array(Type.String()),
-        pageTitle: Type.String(),
-        websiteTitle: Type.String(),
-        accessedDate: Type.Number(),
-        url: Type.String(),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        pageTitle: Type.String({
+            minLength: 1,
+            description: "Title of the web page",
+        }),
+        websiteTitle: Type.String({
+            minLength: 1,
+            description: "Title of the website",
+        }),
+        accessedDate: EncodableDate,
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the web page",
+        }),
     }),
 ]);
 export const BookChapterReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("BookChapter"),
-        chapterTitle: Type.String(),
-        authors: Type.Array(Type.String()),
-        bookTitle: Type.String(),
-        editors: Type.Optional(Type.Array(Type.String())),
-        publisher: Type.String(),
-        location: Type.String(),
-        pages: Type.Optional(Type.String()),
-        isbn: Type.Optional(Type.String()),
+        chapterTitle: Type.String({
+            minLength: 1,
+            description: "Chapter title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Chapter author names",
+        }),
+        bookTitle: Type.String({
+            minLength: 1,
+            description: "Book title",
+        }),
+        editors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Editor names",
+        })),
+        publisher: Type.String({
+            minLength: 1,
+            description: "Publisher name",
+        }),
+        location: Type.String({
+            minLength: 1,
+            description: "Publication location",
+        }),
+        pages: Type.Optional(Type.String({ minLength: 1, description: "Page range" })),
+        isbn: Type.Optional(Type.String({
+            pattern: "^(?:\\d{9}[\\dX]|\\d{13})$",
+            description: "ISBN-10 or ISBN-13 (digits only)",
+        })),
     }),
 ]);
 export const HandbookReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Handbook"),
-        authors: Type.Array(Type.String()),
-        publisher: Type.String(),
-        edition: Type.Optional(Type.String()),
-        location: Type.String(),
-        isbn: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Handbook title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        publisher: Type.String({
+            minLength: 1,
+            description: "Publisher name",
+        }),
+        edition: Type.Optional(Type.String({ minLength: 1, description: "Edition identifier" })),
+        location: Type.String({
+            minLength: 1,
+            description: "Publication location",
+        }),
+        isbn: Type.Optional(Type.String({
+            pattern: "^(?:\\d{9}[\\dX]|\\d{13})$",
+            description: "ISBN-10 or ISBN-13 (digits only)",
+        })),
     }),
 ]);
 export const TechnicalReportReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("TechnicalReport"),
-        authors: Type.Array(Type.String()),
-        reportNumber: Type.String(),
-        institution: Type.String(),
-        location: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Report title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        reportNumber: Type.String({
+            minLength: 1,
+            description: "Report number or identifier",
+        }),
+        institution: Type.String({
+            minLength: 1,
+            description: "Issuing institution",
+        }),
+        location: Type.String({
+            minLength: 1,
+            description: "Institution location",
+        }),
     }),
 ]);
 export const StandardReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Standard"),
-        organization: Type.String(),
-        standardNumber: Type.String(),
-        title: Type.String(),
-        date: Type.String(),
+        organization: Type.String({
+            minLength: 1,
+            description: "Standards organization name",
+        }),
+        standardNumber: Type.String({
+            minLength: 1,
+            description: "Standard number or identifier",
+        }),
+        title: Type.String({
+            minLength: 1,
+            description: "Standard title",
+        }),
+        date: EncodableDate,
     }),
 ]);
 export const ThesisReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Thesis"),
-        authors: Type.Array(Type.String()),
-        degree: Type.String(),
-        institution: Type.String(),
-        location: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Thesis title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        degree: Type.String({
+            minLength: 1,
+            description: "Degree type (e.g. Ph.D., M.S.)",
+        }),
+        institution: Type.String({
+            minLength: 1,
+            description: "Granting institution",
+        }),
+        location: Type.String({
+            minLength: 1,
+            description: "Institution location",
+        }),
     }),
 ]);
 export const PatentReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Patent"),
-        inventors: Type.Array(Type.String()),
-        country: Type.String(),
-        patentNumber: Type.String(),
-        date: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Patent title",
+        }),
+        inventors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Inventor names",
+        }),
+        country: Type.String({
+            minLength: 1,
+            description: "Country of patent",
+        }),
+        patentNumber: Type.String({
+            minLength: 1,
+            description: "Patent number",
+        }),
+        date: EncodableDate,
     }),
 ]);
 export const DictionaryReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Dictionary"),
-        publisher: Type.String(),
-        edition: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Entry title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        publisher: Type.String({
+            minLength: 1,
+            description: "Publisher name",
+        }),
+        edition: Type.Optional(Type.String({ minLength: 1, description: "Edition identifier" })),
     }),
 ]);
 export const EncyclopediaReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Encyclopedia"),
-        publisher: Type.String(),
-        edition: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Entry title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        publisher: Type.String({
+            minLength: 1,
+            description: "Publisher name",
+        }),
+        edition: Type.Optional(Type.String({ minLength: 1, description: "Edition identifier" })),
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -160,33 +327,74 @@ export const JournalArticleReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("JournalArticle"),
-        authors: Type.Array(Type.String()),
-        journalTitle: Type.String(),
-        volume: Type.Optional(Type.String()),
-        issue: Type.Optional(Type.String()),
-        pages: Type.Optional(Type.String()),
-        doi: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Article title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        journalTitle: Type.String({
+            minLength: 1,
+            description: "Journal title",
+        }),
+        volume: Type.Optional(Type.String({ minLength: 1, description: "Volume number" })),
+        issue: Type.Optional(Type.String({ minLength: 1, description: "Issue number" })),
+        pages: Type.Optional(Type.String({ minLength: 1, description: "Page range" })),
+        doi: Type.Optional(Type.String({
+            pattern: "^10\\..+/.+$",
+            description: "DOI identifier",
+        })),
     }),
 ]);
 export const MagazineArticleReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("MagazineArticle"),
-        authors: Type.Array(Type.String()),
-        magazineTitle: Type.String(),
-        volume: Type.Optional(Type.String()),
-        issue: Type.Optional(Type.String()),
-        pages: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Article title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        magazineTitle: Type.String({
+            minLength: 1,
+            description: "Magazine title",
+        }),
+        volume: Type.Optional(Type.String({ minLength: 1, description: "Volume number" })),
+        issue: Type.Optional(Type.String({ minLength: 1, description: "Issue number" })),
+        pages: Type.Optional(Type.String({ minLength: 1, description: "Page range" })),
     }),
 ]);
 export const NewspaperArticleReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("NewspaperArticle"),
-        authors: Type.Array(Type.String()),
-        newspaperTitle: Type.String(),
-        date: Type.String(),
-        pages: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Article title",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        newspaperTitle: Type.String({
+            minLength: 1,
+            description: "Newspaper title",
+        }),
+        date: EncodableDate,
+        pages: Type.Optional(Type.String({ minLength: 1, description: "Page range" })),
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -196,24 +404,54 @@ export const ConferencePaperReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("ConferencePaper"),
-        authors: Type.Array(Type.String()),
-        conferenceName: Type.String(),
-        location: Type.String(),
-        date: Type.String(),
-        pages: Type.Optional(Type.String()),
-        doi: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Paper title",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        conferenceName: Type.String({
+            minLength: 1,
+            description: "Conference name",
+        }),
+        location: Type.String({
+            minLength: 1,
+            description: "Conference location",
+        }),
+        date: EncodableDate,
+        pages: Type.Optional(Type.String({ minLength: 1, description: "Page range" })),
+        doi: Type.Optional(Type.String({
+            pattern: "^10\\..+/.+$",
+            description: "DOI identifier",
+        })),
     }),
 ]);
 export const ConferenceProceedingsReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("ConferenceProceedings"),
-        editors: Type.Optional(Type.Array(Type.String())),
-        conferenceName: Type.String(),
-        location: Type.String(),
-        date: Type.String(),
-        publisher: Type.String(),
-        isbn: Type.Optional(Type.String()),
+        editors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Editor names",
+        })),
+        conferenceName: Type.String({
+            minLength: 1,
+            description: "Conference name",
+        }),
+        location: Type.String({
+            minLength: 1,
+            description: "Conference location",
+        }),
+        date: EncodableDate,
+        publisher: Type.String({
+            minLength: 1,
+            description: "Publisher name",
+        }),
+        isbn: Type.Optional(Type.String({
+            pattern: "^(?:\\d{9}[\\dX]|\\d{13})$",
+            description: "ISBN-10 or ISBN-13 (digits only)",
+        })),
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -223,63 +461,149 @@ export const DatasetReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Dataset"),
-        authors: Type.Optional(Type.Array(Type.String())),
-        repository: Type.String(),
-        version: Type.Optional(Type.String()),
-        doi: Type.Optional(Type.String()),
-        url: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Dataset title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Author names",
+        })),
+        repository: Type.String({
+            minLength: 1,
+            description: "Repository name",
+        }),
+        version: Type.Optional(Type.String({ minLength: 1, description: "Dataset version" })),
+        doi: Type.Optional(Type.String({
+            pattern: "^10\\..+/.+$",
+            description: "DOI identifier",
+        })),
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the dataset",
+        }),
     }),
 ]);
 export const SoftwareReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Software"),
-        authors: Type.Optional(Type.Array(Type.String())),
-        version: Type.Optional(Type.String()),
-        publisher: Type.Optional(Type.String()),
-        doi: Type.Optional(Type.String()),
-        url: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Software title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Author names",
+        })),
+        version: Type.Optional(Type.String({ minLength: 1, description: "Software version" })),
+        publisher: Type.Optional(Type.String({ minLength: 1, description: "Publisher name" })),
+        doi: Type.Optional(Type.String({
+            pattern: "^10\\..+/.+$",
+            description: "DOI identifier",
+        })),
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the software",
+        }),
     }),
 ]);
 export const OnlineDocumentReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("OnlineDocument"),
-        authors: Type.Optional(Type.Array(Type.String())),
-        title: Type.String(),
-        publisher: Type.Optional(Type.String()),
-        url: Type.String(),
-        accessedDate: Type.Number(),
+        authors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Author names",
+        })),
+        title: Type.String({
+            minLength: 1,
+            description: "Document title",
+        }),
+        publisher: Type.Optional(Type.String({ minLength: 1, description: "Publisher name" })),
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the document",
+        }),
+        accessedDate: EncodableDate,
     }),
 ]);
 export const BlogReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Blog"),
-        author: Type.String(),
-        blogTitle: Type.String(),
-        url: Type.String(),
-        accessedDate: Type.String(),
+        author: AuthorSchema,
+        postTitle: Type.String({
+            minLength: 1,
+            description: "Blog post title",
+        }),
+        blogName: Type.String({
+            minLength: 1,
+            description: "Blog name",
+        }),
+        date: EncodableDate,
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the blog post",
+        }),
+        accessedDate: EncodableDate,
     }),
 ]);
 export const SocialMediaReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("SocialMedia"),
-        author: Type.String(),
-        platform: Type.String(),
-        postDate: Type.String(),
-        url: Type.String(),
+        author: AuthorSchema,
+        platform: Type.String({
+            minLength: 1,
+            description: "Social media platform name",
+        }),
+        postDate: EncodableDate,
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the post",
+        }),
     }),
 ]);
 export const PreprintReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Preprint"),
-        authors: Type.Array(Type.String()),
-        server: Type.String(),
-        doi: Type.Optional(Type.String()),
-        url: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Paper title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        authors: Type.Array(AuthorSchema, {
+            minItems: 1,
+            description: "Author names",
+        }),
+        server: Type.String({
+            minLength: 1,
+            description: "Preprint server name",
+        }),
+        doi: Type.Optional(Type.String({
+            pattern: "^10\\..+/.+$",
+            description: "DOI identifier",
+        })),
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the preprint",
+        }),
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -289,42 +613,95 @@ export const VideoReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Video"),
-        authors: Type.Optional(Type.Array(Type.String())),
-        platform: Type.String(),
-        url: Type.String(),
-        accessedDate: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Video title",
+        }),
+        authors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Author or creator names",
+        })),
+        releaseDate: Type.Optional(EncodableDate),
+        platform: Type.String({
+            minLength: 1,
+            description: "Video hosting platform",
+        }),
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the video",
+        }),
+        accessedDate: EncodableDate,
     }),
 ]);
 export const PodcastReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Podcast"),
-        authors: Type.Optional(Type.Array(Type.String())),
-        episodeTitle: Type.String(),
-        seriesTitle: Type.String(),
-        platform: Type.String(),
-        url: Type.String(),
-        accessedDate: Type.String(),
+        authors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Host or producer names",
+        })),
+        episodeTitle: Type.String({
+            minLength: 1,
+            description: "Episode title",
+        }),
+        seriesTitle: Type.String({
+            minLength: 1,
+            description: "Podcast series title",
+        }),
+        platform: Type.String({
+            minLength: 1,
+            description: "Podcast platform",
+        }),
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the episode",
+        }),
+        accessedDate: EncodableDate,
     }),
 ]);
 export const CourseReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Course"),
-        instructor: Type.String(),
-        institution: Type.String(),
-        courseCode: Type.Optional(Type.String()),
-        term: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Course title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        instructor: AuthorSchema,
+        institution: Type.String({
+            minLength: 1,
+            description: "Offering institution",
+        }),
+        courseCode: Type.Optional(Type.String({ minLength: 1, description: "Course code" })),
+        term: Type.String({
+            minLength: 1,
+            description: "Academic term",
+        }),
     }),
 ]);
 export const PresentationReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Presentation"),
-        presenter: Type.String(),
-        eventTitle: Type.String(),
-        location: Type.String(),
-        date: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Presentation title",
+        }),
+        presenter: AuthorSchema,
+        eventTitle: Type.String({
+            minLength: 1,
+            description: "Event or conference title",
+        }),
+        location: Type.String({
+            minLength: 1,
+            description: "Event location",
+        }),
+        date: EncodableDate,
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -334,26 +711,26 @@ export const InterviewReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Interview"),
-        interviewee: Type.String(),
-        interviewer: Type.Optional(Type.String()),
-        date: Type.String(),
+        interviewee: AuthorSchema,
+        interviewer: Type.Optional(AuthorSchema),
+        date: EncodableDate,
     }),
 ]);
 export const PersonalCommunicationReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("PersonalCommunication"),
-        person: Type.String(),
-        date: Type.String(),
+        person: AuthorSchema,
+        date: EncodableDate,
     }),
 ]);
 export const EmailReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Email"),
-        sender: Type.String(),
-        recipient: Type.String(),
-        date: Type.String(),
+        sender: AuthorSchema,
+        recipient: AuthorSchema,
+        date: EncodableDate,
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -363,29 +740,57 @@ export const LawReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Law"),
-        title: Type.String(),
-        jurisdiction: Type.String(),
-        dateEnacted: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Law title",
+        }),
+        jurisdiction: Type.String({
+            minLength: 1,
+            description: "Jurisdiction",
+        }),
+        dateEnacted: EncodableDate,
     }),
 ]);
 export const CourtCaseReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("CourtCase"),
-        caseName: Type.String(),
-        court: Type.String(),
-        date: Type.String(),
-        reporter: Type.Optional(Type.String()),
+        caseName: Type.String({
+            minLength: 1,
+            description: "Case name",
+        }),
+        court: Type.String({
+            minLength: 1,
+            description: "Court name",
+        }),
+        date: EncodableDate,
+        reporter: Type.Optional(Type.String({ minLength: 1, description: "Reporter citation" })),
     }),
 ]);
 export const GovernmentPublicationReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("GovernmentPublication"),
-        authors: Type.Optional(Type.Array(Type.String())),
-        agency: Type.String(),
-        reportNumber: Type.Optional(Type.String()),
-        location: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Publication title",
+        }),
+        date: EncodableDate,
+        authors: Type.Optional(Type.Array(AuthorSchema, {
+            description: "Author names",
+        })),
+        agency: Type.String({
+            minLength: 1,
+            description: "Government agency",
+        }),
+        reportNumber: Type.Optional(Type.String({
+            minLength: 1,
+            description: "Report number",
+        })),
+        location: Type.String({
+            minLength: 1,
+            description: "Publication location",
+        }),
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -395,18 +800,54 @@ export const DatasheetReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("Datasheet"),
-        manufacturer: Type.String(),
-        partNumber: Type.String(),
-        url: Type.String(),
+        title: Type.String({
+            minLength: 1,
+            description: "Datasheet title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        manufacturer: Type.String({
+            minLength: 1,
+            description: "Manufacturer name",
+        }),
+        partNumber: Type.String({
+            minLength: 1,
+            description: "Part number",
+        }),
+        url: Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the datasheet",
+        }),
     }),
 ]);
 export const ProductManualReferenceSchema = Type.Intersect([
     BaseReferenceSchema,
     Type.Object({
         type: Type.Literal("ProductManual"),
-        manufacturer: Type.String(),
-        model: Type.String(),
-        url: Type.Optional(Type.String()),
+        title: Type.String({
+            minLength: 1,
+            description: "Manual title",
+        }),
+        year: Type.String({
+            pattern: "^\\d{4}$",
+            description: "Four-digit publication year",
+        }),
+        manufacturer: Type.String({
+            minLength: 1,
+            description: "Manufacturer name",
+        }),
+        model: Type.String({
+            minLength: 1,
+            description: "Product model",
+        }),
+        url: Type.Optional(Type.String({
+            format: "uri",
+            minLength: 1,
+            description: "URL of the manual",
+        })),
     }),
 ]);
 // ---------------------------------------------------------------------------
@@ -447,4 +888,42 @@ export const IEEEReferenceSchema = Type.Union([
     DatasheetReferenceSchema,
     ProductManualReferenceSchema,
 ]);
+// ---------------------------------------------------------------------------
+// Schema map keyed by reference type
+// ---------------------------------------------------------------------------
+export const IEEEReferenceSchemaMap = {
+    Book: BookReferenceSchema,
+    Website: WebsiteReferenceSchema,
+    BookChapter: BookChapterReferenceSchema,
+    Handbook: HandbookReferenceSchema,
+    TechnicalReport: TechnicalReportReferenceSchema,
+    Standard: StandardReferenceSchema,
+    Thesis: ThesisReferenceSchema,
+    Patent: PatentReferenceSchema,
+    Dictionary: DictionaryReferenceSchema,
+    Encyclopedia: EncyclopediaReferenceSchema,
+    JournalArticle: JournalArticleReferenceSchema,
+    MagazineArticle: MagazineArticleReferenceSchema,
+    NewspaperArticle: NewspaperArticleReferenceSchema,
+    ConferencePaper: ConferencePaperReferenceSchema,
+    ConferenceProceedings: ConferenceProceedingsReferenceSchema,
+    Dataset: DatasetReferenceSchema,
+    Software: SoftwareReferenceSchema,
+    OnlineDocument: OnlineDocumentReferenceSchema,
+    Blog: BlogReferenceSchema,
+    SocialMedia: SocialMediaReferenceSchema,
+    Preprint: PreprintReferenceSchema,
+    Video: VideoReferenceSchema,
+    Podcast: PodcastReferenceSchema,
+    Course: CourseReferenceSchema,
+    Presentation: PresentationReferenceSchema,
+    Interview: InterviewReferenceSchema,
+    PersonalCommunication: PersonalCommunicationReferenceSchema,
+    Email: EmailReferenceSchema,
+    Law: LawReferenceSchema,
+    CourtCase: CourtCaseReferenceSchema,
+    GovernmentPublication: GovernmentPublicationReferenceSchema,
+    Datasheet: DatasheetReferenceSchema,
+    ProductManual: ProductManualReferenceSchema,
+};
 //# sourceMappingURL=references.js.map