geo-semantic-layer 2.0.1

package/dist/generators/index.js

@@ -0,0 +1,969 @@
+import { z } from 'zod';
+
+// src/core/schemas/organization.ts
+var PostalAddressSchema = z.object({
+  "@type": z.literal("PostalAddress").default("PostalAddress"),
+  streetAddress: z.string().optional(),
+  addressLocality: z.string().optional(),
+  addressRegion: z.string().optional(),
+  postalCode: z.string().optional(),
+  addressCountry: z.string().length(2).optional()
+  // ISO 3166-1 alpha-2
+});
+var ContactPointSchema = z.object({
+  "@type": z.literal("ContactPoint").default("ContactPoint"),
+  telephone: z.string().optional(),
+  email: z.string().email().optional(),
+  contactType: z.enum(["customer service", "technical support", "sales", "billing"]).optional(),
+  areaServed: z.string().optional(),
+  availableLanguage: z.array(z.string()).optional()
+});
+var OrganizationSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("Organization").default("Organization"),
+  // Required fields
+  name: z.string().min(1, "Organization name is required"),
+  url: z.string().url("Must be a valid URL"),
+  // Recommended fields
+  logo: z.string().url("Logo must be a valid URL").optional(),
+  image: z.string().url("Image must be a valid URL").optional(),
+  description: z.string().min(10, "Description should be at least 10 characters").optional(),
+  /**
+   * CRITICAL for GEO: Entity disambiguation
+   * Should include at least one social profile or authority ID (Wikidata, Wikipedia, etc.)
+   */
+  sameAs: z.array(z.string().url()).min(1, "At least one sameAs URL is required for entity disambiguation").describe("Social profiles, Wikidata ID, Wikipedia URL for entity disambiguation"),
+  // Contact information
+  email: z.string().email().optional(),
+  telephone: z.string().optional(),
+  address: PostalAddressSchema.optional(),
+  contactPoint: z.union([ContactPointSchema, z.array(ContactPointSchema)]).optional(),
+  // Additional information
+  alternateName: z.string().optional(),
+  foundingDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be in YYYY-MM-DD format").optional(),
+  founder: z.array(z.string()).optional(),
+  // Relationships
+  parentOrganization: z.string().optional(),
+  subOrganization: z.array(z.string()).optional()
+});
+var PersonSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("Person").default("Person"),
+  // Required fields
+  name: z.string().min(1, "Person name is required"),
+  url: z.string().url("Must be a valid URL").optional(),
+  // Recommended fields
+  image: z.string().url("Image must be a valid URL").optional(),
+  description: z.string().min(10, "Description should be at least 10 characters").optional(),
+  /**
+   * CRITICAL for GEO: Entity disambiguation
+   * Should include social profiles, Wikidata ID, Wikipedia URL, etc.
+   */
+  sameAs: z.array(z.string().url()).min(1, "At least one sameAs URL is required for entity disambiguation").describe("Social profiles, Wikidata ID, Wikipedia URL for entity disambiguation"),
+  // Contact information
+  email: z.string().email().optional(),
+  telephone: z.string().optional(),
+  address: PostalAddressSchema.optional(),
+  // Professional information
+  jobTitle: z.string().optional(),
+  worksFor: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string(),
+    url: z.string().url().optional()
+  }).optional(),
+  // Additional information
+  alternateName: z.string().optional(),
+  birthDate: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Must be in YYYY-MM-DD format").optional(),
+  nationality: z.string().optional(),
+  // Relationships
+  colleague: z.array(z.string()).optional(),
+  alumniOf: z.string().optional()
+});
+var OfferSchema = z.object({
+  "@type": z.literal("Offer").default("Offer"),
+  price: z.union([z.string(), z.number()]),
+  priceCurrency: z.string().length(3),
+  // ISO 4217 currency code
+  availability: z.string().url().optional().describe("e.g., https://schema.org/InStock"),
+  url: z.string().url().optional(),
+  priceValidUntil: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+  seller: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string()
+  }).optional()
+});
+var AggregateRatingSchema = z.object({
+  "@type": z.literal("AggregateRating").default("AggregateRating"),
+  ratingValue: z.union([z.string(), z.number()]),
+  reviewCount: z.number().int().positive(),
+  bestRating: z.union([z.string(), z.number()]).optional().default(5),
+  worstRating: z.union([z.string(), z.number()]).optional().default(1)
+});
+var ReviewSchema = z.object({
+  "@type": z.literal("Review").default("Review"),
+  author: z.object({
+    "@type": z.literal("Person"),
+    name: z.string()
+  }),
+  datePublished: z.string().regex(/^\d{4}-\d{2}-\d{2}$/),
+  reviewBody: z.string().min(10),
+  reviewRating: z.object({
+    "@type": z.literal("Rating"),
+    ratingValue: z.union([z.string(), z.number()]),
+    bestRating: z.union([z.string(), z.number()]).optional().default(5)
+  })
+});
+var ProductSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("Product").default("Product"),
+  // Required fields
+  name: z.string().min(1, "Product name is required"),
+  // Recommended fields
+  image: z.union([z.string().url(), z.array(z.string().url())]).optional(),
+  description: z.string().min(10, "Description should be at least 10 characters").optional(),
+  // SKU or other identifiers
+  sku: z.string().optional(),
+  gtin: z.string().optional(),
+  gtin8: z.string().optional(),
+  gtin12: z.string().optional(),
+  gtin13: z.string().optional(),
+  gtin14: z.string().optional(),
+  mpn: z.string().optional(),
+  // Brand
+  brand: z.object({
+    "@type": z.literal("Brand"),
+    name: z.string()
+  }).optional(),
+  // Offers (pricing)
+  offers: z.union([OfferSchema, z.array(OfferSchema)]).optional(),
+  // Ratings and Reviews
+  aggregateRating: AggregateRatingSchema.optional(),
+  review: z.union([ReviewSchema, z.array(ReviewSchema)]).optional(),
+  // Additional information
+  category: z.string().optional(),
+  color: z.union([z.string(), z.array(z.string())]).optional(),
+  material: z.string().optional(),
+  manufacturer: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string()
+  }).optional()
+});
+var ArticleSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.enum(["Article", "NewsArticle", "BlogPosting", "TechArticle"]).default("Article"),
+  // Required fields
+  headline: z.string().min(1).max(110, "Headline should be less than 110 characters for optimal SEO"),
+  image: z.union([z.string().url(), z.array(z.string().url())]),
+  // Recommended fields
+  author: z.union([
+    z.object({
+      "@type": z.enum(["Person", "Organization"]),
+      name: z.string(),
+      url: z.string().url().optional()
+    }),
+    z.array(
+      z.object({
+        "@type": z.enum(["Person", "Organization"]),
+        name: z.string(),
+        url: z.string().url().optional()
+      })
+    )
+  ]).describe("Author(s) of the article"),
+  datePublished: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/, "Must be ISO 8601 format"),
+  dateModified: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/, "Must be ISO 8601 format").optional(),
+  // Publisher (recommended for Google News)
+  publisher: z.object({
+    "@type": z.literal("Organization"),
+    name: z.string(),
+    logo: z.object({
+      "@type": z.literal("ImageObject"),
+      url: z.string().url(),
+      width: z.number().optional(),
+      height: z.number().optional()
+    }).optional()
+  }).optional(),
+  // Content
+  description: z.string().min(10).optional(),
+  articleBody: z.string().min(50, "Article body should be at least 50 characters").optional(),
+  wordCount: z.number().int().positive().optional(),
+  // Additional metadata
+  url: z.string().url().optional(),
+  mainEntityOfPage: z.string().url().optional(),
+  keywords: z.union([z.string(), z.array(z.string())]).optional(),
+  articleSection: z.string().optional(),
+  inLanguage: z.string().optional()
+});
+ArticleSchema.extend({
+  "@type": z.literal("BlogPosting").default("BlogPosting")
+});
+ArticleSchema.extend({
+  "@type": z.literal("NewsArticle").default("NewsArticle"),
+  dateline: z.string().optional()
+});
+var QuestionSchema = z.object({
+  "@type": z.literal("Question").default("Question"),
+  name: z.string().min(1, "Question text is required"),
+  acceptedAnswer: z.object({
+    "@type": z.literal("Answer").default("Answer"),
+    text: z.string().min(1, "Answer text is required")
+  })
+});
+var FAQPageSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("FAQPage").default("FAQPage"),
+  mainEntity: z.array(QuestionSchema).min(1, "At least one question is required for FAQ").describe("Array of questions and answers")
+});
+var ListItemSchema = z.object({
+  "@type": z.literal("ListItem").default("ListItem"),
+  position: z.number().int().positive(),
+  name: z.string().min(1),
+  item: z.string().url().optional()
+});
+var BreadcrumbListSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("BreadcrumbList").default("BreadcrumbList"),
+  itemListElement: z.array(ListItemSchema).min(2, "Breadcrumb list must have at least 2 items").describe("Ordered list of breadcrumb items")
+});
+var WebPageSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.literal("WebPage").default("WebPage"),
+  name: z.string().min(1),
+  description: z.string().min(10).optional(),
+  url: z.string().url(),
+  // Optional fields
+  inLanguage: z.string().optional(),
+  isPartOf: z.object({
+    "@type": z.literal("WebSite"),
+    name: z.string(),
+    url: z.string().url()
+  }).optional(),
+  breadcrumb: z.object({
+    "@type": z.literal("BreadcrumbList")
+  }).optional(),
+  datePublished: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/).optional(),
+  dateModified: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}Z)?$/).optional(),
+  author: z.object({
+    "@type": z.enum(["Person", "Organization"]),
+    name: z.string()
+  }).optional()
+});
+var OpenGraphSchema = z.object({
+  title: z.string().min(1).max(60, "Title should be less than 60 characters for optimal display"),
+  description: z.string().min(1).max(160, "Description should be less than 160 characters"),
+  url: z.string().url(),
+  type: z.enum(["website", "article", "product", "book", "profile", "music", "video"]).default("website"),
+  image: z.string().url(),
+  imageAlt: z.string().optional(),
+  siteName: z.string().optional(),
+  locale: z.string().default("en_US"),
+  // Article-specific
+  publishedTime: z.string().optional(),
+  modifiedTime: z.string().optional(),
+  author: z.string().optional(),
+  section: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  // Product-specific
+  price: z.union([z.string(), z.number()]).optional(),
+  currency: z.string().length(3).optional()
+});
+var TwitterCardSchema = z.object({
+  card: z.enum(["summary", "summary_large_image", "app", "player"]).default("summary_large_image"),
+  site: z.string().optional(),
+  // @username
+  creator: z.string().optional(),
+  // @username
+  title: z.string().min(1).max(70, "Twitter title should be less than 70 characters"),
+  description: z.string().min(1).max(200, "Twitter description should be less than 200 characters"),
+  image: z.string().url(),
+  imageAlt: z.string().optional()
+});
+var GeoCoordinatesSchema = z.object({
+  "@type": z.literal("GeoCoordinates").default("GeoCoordinates"),
+  latitude: z.number().min(-90).max(90),
+  longitude: z.number().min(-180).max(180)
+});
+var OpeningHoursSchema = z.object({
+  "@type": z.literal("OpeningHoursSpecification").default("OpeningHoursSpecification"),
+  dayOfWeek: z.union([
+    z.enum(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]),
+    z.array(z.enum(["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]))
+  ]),
+  opens: z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Must be in HH:MM format"),
+  closes: z.string().regex(/^([01]\d|2[0-3]):([0-5]\d)$/, "Must be in HH:MM format")
+});
+var LocalBusinessSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.string().default("LocalBusiness"),
+  // Can be Restaurant, Store, etc.
+  // Required
+  name: z.string().min(1, "Business name is required"),
+  image: z.union([z.string().url(), z.array(z.string().url())]),
+  address: PostalAddressSchema,
+  // Recommended
+  "@id": z.string().url().optional(),
+  url: z.string().url().optional(),
+  telephone: z.string().optional(),
+  priceRange: z.string().optional(),
+  // e.g., "$$"
+  // Location
+  geo: GeoCoordinatesSchema.optional(),
+  // Opening hours
+  openingHoursSpecification: z.union([
+    OpeningHoursSchema,
+    z.array(OpeningHoursSchema)
+  ]).optional(),
+  // Ratings
+  aggregateRating: z.object({
+    "@type": z.literal("AggregateRating"),
+    ratingValue: z.union([z.string(), z.number()]),
+    reviewCount: z.number().int().positive()
+  }).optional(),
+  // Additional info
+  description: z.string().min(10).optional(),
+  servesCuisine: z.union([z.string(), z.array(z.string())]).optional(),
+  // For restaurants
+  menu: z.string().url().optional(),
+  // For restaurants
+  acceptsReservations: z.union([z.boolean(), z.string()]).optional(),
+  paymentAccepted: z.string().optional()
+});
+var PlaceSchema = z.object({
+  "@type": z.literal("Place").default("Place"),
+  name: z.string(),
+  address: z.union([
+    z.string(),
+    z.object({
+      "@type": z.literal("PostalAddress"),
+      streetAddress: z.string().optional(),
+      addressLocality: z.string().optional(),
+      addressRegion: z.string().optional(),
+      postalCode: z.string().optional(),
+      addressCountry: z.string().optional()
+    })
+  ]).optional()
+});
+var EventOfferSchema = z.object({
+  "@type": z.literal("Offer").default("Offer"),
+  url: z.string().url().optional(),
+  price: z.union([z.string(), z.number()]),
+  priceCurrency: z.string().length(3),
+  availability: z.string().url().optional(),
+  validFrom: z.string().optional()
+});
+var EventSchema = z.object({
+  "@context": z.literal("https://schema.org").default("https://schema.org"),
+  "@type": z.enum(["Event", "MusicEvent", "BusinessEvent", "SportsEvent", "TheaterEvent", "EducationEvent"]).default("Event"),
+  // Required
+  name: z.string().min(1, "Event name is required"),
+  startDate: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2})?$/, "Must be ISO 8601 format"),
+  // Recommended
+  endDate: z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2})?$/, "Must be ISO 8601 format").optional(),
+  eventStatus: z.enum([
+    "https://schema.org/EventScheduled",
+    "https://schema.org/EventCancelled",
+    "https://schema.org/EventMovedOnline",
+    "https://schema.org/EventPostponed",
+    "https://schema.org/EventRescheduled"
+  ]).optional(),
+  eventAttendanceMode: z.enum([
+    "https://schema.org/OfflineEventAttendanceMode",
+    "https://schema.org/OnlineEventAttendanceMode",
+    "https://schema.org/MixedEventAttendanceMode"
+  ]).optional(),
+  location: z.union([PlaceSchema, z.string().url()]).optional(),
+  // Can be Place or VirtualLocation URL
+  image: z.union([z.string().url(), z.array(z.string().url())]).optional(),
+  description: z.string().min(10).optional(),
+  // Organizer
+  organizer: z.object({
+    "@type": z.enum(["Organization", "Person"]),
+    name: z.string(),
+    url: z.string().url().optional()
+  }).optional(),
+  // Performer
+  performer: z.union([
+    z.object({
+      "@type": z.enum(["Person", "PerformingGroup"]),
+      name: z.string()
+    }),
+    z.array(z.object({
+      "@type": z.enum(["Person", "PerformingGroup"]),
+      name: z.string()
+    }))
+  ]).optional(),
+  // Offers (tickets)
+  offers: z.union([EventOfferSchema, z.array(EventOfferSchema)]).optional(),
+  // Additional
+  url: z.string().url().optional()
+});
+
+// src/core/geo/processor.ts
+var GeoProcessor = class {
+  /**
+   * Optimizes schema density based on configuration.
+   * Removes nulls, undefined, and non-essential fields for 'high' density (AI-focused).
+   */
+  static optimizeDensity(schema, density = "low") {
+    if (density === "low") {
+      return this.pruneEmpty(schema);
+    }
+    const optimized = this.pruneEmpty(schema);
+    if (density === "high") {
+      const aiEssentialKeys = [
+        "@context",
+        "@type",
+        "name",
+        "headline",
+        "description",
+        "url",
+        "sameAs",
+        "author",
+        "datePublished",
+        "publisher",
+        "itemListElement",
+        "item",
+        "position"
+      ];
+      return this.filterRecursive(optimized, (key) => aiEssentialKeys.includes(key));
+    }
+    return optimized;
+  }
+  /**
+   * Recursively removes null, undefined, and empty strings/arrays
+   */
+  static pruneEmpty(obj) {
+    if (Array.isArray(obj)) {
+      return obj.map((v) => this.pruneEmpty(v)).filter((v) => v !== null && v !== void 0 && v !== "");
+    }
+    if (obj !== null && typeof obj === "object") {
+      return Object.entries(obj).reduce((acc, [key, value]) => {
+        const pruned = this.pruneEmpty(value);
+        if (pruned !== null && pruned !== void 0 && pruned !== "" && (!Array.isArray(pruned) || pruned.length > 0) && (typeof pruned !== "object" || Object.keys(pruned).length > 0)) {
+          acc[key] = pruned;
+        }
+        return acc;
+      }, {});
+    }
+    return obj;
+  }
+  /**
+   * Filter object keys recursively based on a predicate
+   */
+  static filterRecursive(obj, predicate) {
+    if (Array.isArray(obj)) {
+      return obj.map((v) => this.filterRecursive(v, predicate));
+    }
+    if (obj !== null && typeof obj === "object") {
+      return Object.entries(obj).reduce((acc, [key, value]) => {
+        if (key === "@type" || key === "@context" || predicate(key)) {
+          acc[key] = this.filterRecursive(value, predicate);
+        }
+        return acc;
+      }, {});
+    }
+    return obj;
+  }
+  /**
+   * Validates authority links to prevent hallucinations.
+   * Checks if sameAs links match known authoritative patterns.
+   */
+  static validateAuthorities(sameAs = []) {
+    const authorityPatterns = [
+      /wikipedia\.org/,
+      /wikidata\.org/,
+      /linkedin\.com/,
+      /twitter\.com/,
+      /x\.com/,
+      /facebook\.com/,
+      /instagram\.com/,
+      /github\.com/,
+      /crunchbase\.com/
+    ];
+    const valid = [];
+    const warnings = [];
+    sameAs.forEach((url) => {
+      try {
+        const parsed = new URL(url);
+        const isAuthority = authorityPatterns.some((pattern) => pattern.test(parsed.hostname));
+        if (isAuthority) {
+          valid.push(url);
+        } else {
+          warnings.push(`Low authority or unknown source: ${url}`);
+        }
+      } catch (e) {
+        warnings.push(`Invalid URL format: ${url}`);
+      }
+    });
+    return { valid, warnings };
+  }
+};
+
+// src/core/generators/identity.ts
+function generateIdentitySchema(config) {
+  if (config.type === "Organization") {
+    const orgConfig = {
+      name: config.name,
+      ...config.alternateName && { alternateName: config.alternateName },
+      ...config.url && { url: config.url },
+      ...config.logoUrl && { logo: config.logoUrl },
+      ...config.description && { description: config.description },
+      ...config.sameAs && { sameAs: config.sameAs },
+      ...config.email && { email: config.email },
+      ...config.telephone && { telephone: config.telephone },
+      ...config.address && { address: config.address },
+      ...config.contactPoint && { contactPoint: config.contactPoint },
+      ...config.foundingDate && { foundingDate: config.foundingDate },
+      ...config.founder && {
+        founder: Array.isArray(config.founder) ? config.founder : [config.founder]
+      },
+      ...config.geo && { geo: config.geo }
+    };
+    return generateOrganizationSchema(orgConfig);
+  } else {
+    const personConfig = {
+      name: config.name,
+      ...config.url && { url: config.url },
+      ...config.imageUrl && { image: config.imageUrl },
+      ...config.description && { description: config.description },
+      ...config.jobTitle && { jobTitle: config.jobTitle },
+      ...config.sameAs && { sameAs: config.sameAs },
+      ...config.email && { email: config.email },
+      ...config.telephone && { telephone: config.telephone },
+      ...config.address && { address: config.address },
+      ...config.worksFor && { worksFor: config.worksFor },
+      ...config.geo && { geo: config.geo }
+    };
+    return generatePersonSchema(personConfig);
+  }
+}
+function generateOrganizationSchema(config) {
+  if (config.geo?.enableHallucinationGuard && config.sameAs) {
+    const { warnings } = GeoProcessor.validateAuthorities(config.sameAs);
+    if (warnings.length > 0) {
+      console.warn("[SemanticLayer:GEO] Authority validation warnings:", warnings);
+    }
+  }
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Organization",
+    name: config.name,
+    ...config.alternateName && { alternateName: config.alternateName },
+    ...config.url && { url: config.url },
+    ...config.description && { description: config.description },
+    ...config.logo && { logo: config.logo },
+    ...config.sameAs && config.sameAs.length > 0 && { sameAs: config.sameAs },
+    ...config.email && { email: config.email },
+    ...config.telephone && { telephone: config.telephone },
+    ...config.address && {
+      address: {
+        "@type": "PostalAddress",
+        ...config.address
+      }
+    },
+    ...config.contactPoint && {
+      contactPoint: {
+        "@type": "ContactPoint",
+        ...config.contactPoint
+      }
+    },
+    ...config.foundingDate && { foundingDate: config.foundingDate },
+    ...config.founder && { founder: Array.isArray(config.founder) ? config.founder : [config.founder] },
+    ...config.numberOfEmployees && { numberOfEmployees: config.numberOfEmployees }
+  };
+  const parsed = OrganizationSchema.parse(schema);
+  if (config.geo) {
+    return GeoProcessor.optimizeDensity(parsed, config.geo.contentDensity);
+  }
+  return parsed;
+}
+function generatePersonSchema(config) {
+  if (config.geo?.enableHallucinationGuard && config.sameAs) {
+    const { warnings } = GeoProcessor.validateAuthorities(config.sameAs);
+    if (warnings.length > 0) {
+      console.warn("[SemanticLayer:GEO] Authority validation warnings:", warnings);
+    }
+  }
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Person",
+    name: config.name,
+    ...config.url && { url: config.url },
+    ...config.description && { description: config.description },
+    ...config.image && { image: config.image },
+    ...config.sameAs && config.sameAs.length > 0 && { sameAs: config.sameAs },
+    ...config.email && { email: config.email },
+    ...config.telephone && { telephone: config.telephone },
+    ...config.address && {
+      address: {
+        "@type": "PostalAddress",
+        ...config.address
+      }
+    },
+    ...config.jobTitle && { jobTitle: config.jobTitle },
+    ...config.worksFor && {
+      worksFor: typeof config.worksFor === "string" ? { "@type": "Organization", name: config.worksFor } : config.worksFor
+    },
+    ...config.birthDate && { birthDate: config.birthDate }
+  };
+  const parsed = PersonSchema.parse(schema);
+  if (config.geo) {
+    return GeoProcessor.optimizeDensity(parsed, config.geo.contentDensity);
+  }
+  return parsed;
+}
+function serializeSchema(schema) {
+  return JSON.stringify(schema, null, 2);
+}
+function generateScriptTag(schema) {
+  const serialized = serializeSchema(schema);
+  return `<script type="application/ld+json">
+${serialized}
+</script>`;
+}
+
+// src/core/generators/product.ts
+function generateProductSchema(config) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Product",
+    name: config.name,
+    ...config.description && { description: config.description },
+    ...config.image && { image: config.image },
+    ...config.sku && { sku: config.sku },
+    ...config.gtin && { gtin: config.gtin },
+    ...config.brand && {
+      brand: {
+        "@type": "Brand",
+        name: config.brand
+      }
+    },
+    ...config.offers && {
+      offers: Array.isArray(config.offers) ? config.offers.map((offer) => convertOffer(offer)) : convertOffer(config.offers)
+    },
+    ...config.aggregateRating && {
+      aggregateRating: {
+        "@type": "AggregateRating",
+        ...config.aggregateRating
+      }
+    },
+    ...config.category && { category: config.category },
+    ...config.color && { color: config.color }
+  };
+  return ProductSchema.parse(schema);
+}
+function convertOffer(config) {
+  return {
+    "@type": "Offer",
+    price: config.price,
+    priceCurrency: config.priceCurrency,
+    ...config.availability && { availability: config.availability },
+    ...config.url && { url: config.url },
+    ...config.priceValidUntil && { priceValidUntil: config.priceValidUntil },
+    ...config.seller && {
+      seller: {
+        "@type": "Organization",
+        name: config.seller.name
+      }
+    }
+  };
+}
+
+// src/core/generators/article.ts
+function generateArticleSchema(config) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "Article",
+    headline: config.headline,
+    image: config.image,
+    author: convertAuthor(config.author),
+    datePublished: config.datePublished,
+    ...config.dateModified && { dateModified: config.dateModified },
+    ...config.description && { description: config.description },
+    ...config.articleBody && { articleBody: config.articleBody },
+    ...config.publisher && {
+      publisher: {
+        "@type": "Organization",
+        name: config.publisher.name,
+        ...config.publisher.logo && {
+          logo: {
+            "@type": "ImageObject",
+            url: config.publisher.logo
+          }
+        }
+      }
+    },
+    ...config.url && { url: config.url },
+    ...config.keywords && { keywords: config.keywords },
+    ...config.articleSection && { articleSection: config.articleSection }
+  };
+  const parsed = ArticleSchema.parse(schema);
+  if (config.geo) {
+    return GeoProcessor.optimizeDensity(parsed, config.geo.contentDensity);
+  }
+  return parsed;
+}
+function convertAuthor(author) {
+  if (typeof author === "string") {
+    return {
+      "@type": "Person",
+      name: author
+    };
+  }
+  if (Array.isArray(author)) {
+    return author.map((a) => ({
+      "@type": "Person",
+      name: a.name,
+      ...a.url && { url: a.url }
+    }));
+  }
+  return {
+    "@type": "Person",
+    name: author.name,
+    ...author.url && { url: author.url }
+  };
+}
+
+// src/core/generators/faq.ts
+function generateFAQSchema(config) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "FAQPage",
+    mainEntity: config.questions.map((q) => ({
+      "@type": "Question",
+      name: q.question,
+      acceptedAnswer: {
+        "@type": "Answer",
+        text: q.answer
+      }
+    }))
+  };
+  return FAQPageSchema.parse(schema);
+}
+
+// src/core/generators/breadcrumb.ts
+function generateBreadcrumbSchema(config) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "BreadcrumbList",
+    itemListElement: config.items.map((item, index) => ({
+      "@type": "ListItem",
+      position: index + 1,
+      name: item.name,
+      ...item.url && { item: item.url }
+    }))
+  };
+  return BreadcrumbListSchema.parse(schema);
+}
+
+// src/core/generators/opengraph.ts
+function generateOpenGraphTags(config) {
+  const validated = OpenGraphSchema.parse(config);
+  const tags = [
+    { property: "og:title", content: validated.title },
+    { property: "og:description", content: validated.description },
+    { property: "og:url", content: validated.url },
+    { property: "og:type", content: validated.type },
+    { property: "og:image", content: validated.image },
+    { property: "og:locale", content: validated.locale }
+  ];
+  if (validated.imageAlt) {
+    tags.push({ property: "og:image:alt", content: validated.imageAlt });
+  }
+  if (validated.siteName) {
+    tags.push({ property: "og:site_name", content: validated.siteName });
+  }
+  if (validated.type === "article") {
+    if (validated.publishedTime) {
+      tags.push({ property: "article:published_time", content: validated.publishedTime });
+    }
+    if (validated.modifiedTime) {
+      tags.push({ property: "article:modified_time", content: validated.modifiedTime });
+    }
+    if (validated.author) {
+      tags.push({ property: "article:author", content: validated.author });
+    }
+    if (validated.section) {
+      tags.push({ property: "article:section", content: validated.section });
+    }
+    if (validated.tags) {
+      validated.tags.forEach((tag) => {
+        tags.push({ property: "article:tag", content: tag });
+      });
+    }
+  }
+  if (validated.type === "product") {
+    if (validated.price) {
+      tags.push({ property: "product:price:amount", content: String(validated.price) });
+    }
+    if (validated.currency) {
+      tags.push({ property: "product:price:currency", content: validated.currency });
+    }
+  }
+  return tags;
+}
+function generateTwitterCardTags(config) {
+  const validated = TwitterCardSchema.parse(config);
+  const tags = [
+    { name: "twitter:card", content: validated.card },
+    { name: "twitter:title", content: validated.title },
+    { name: "twitter:description", content: validated.description },
+    { name: "twitter:image", content: validated.image }
+  ];
+  if (validated.site) {
+    tags.push({ name: "twitter:site", content: validated.site });
+  }
+  if (validated.creator) {
+    tags.push({ name: "twitter:creator", content: validated.creator });
+  }
+  if (validated.imageAlt) {
+    tags.push({ name: "twitter:image:alt", content: validated.imageAlt });
+  }
+  return tags;
+}
+function generateSocialMetaTags(config) {
+  const openGraph = generateOpenGraphTags({
+    title: config.title,
+    description: config.description,
+    url: config.url,
+    image: config.image,
+    ...config.imageAlt && { imageAlt: config.imageAlt },
+    ...config.type && { type: config.type },
+    ...config.siteName && { siteName: config.siteName }
+  });
+  const twitter = generateTwitterCardTags({
+    title: config.title,
+    description: config.description,
+    image: config.image,
+    ...config.imageAlt && { imageAlt: config.imageAlt },
+    ...config.twitterSite && { site: config.twitterSite },
+    ...config.twitterCreator && { creator: config.twitterCreator },
+    ...config.twitterCard && { card: config.twitterCard }
+  });
+  return { openGraph, twitter };
+}
+function metaTagsToHTML(tags) {
+  return tags.map((tag) => {
+    const attr = tag.property ? `property="${tag.property}"` : `name="${tag.name}"`;
+    return `<meta ${attr} content="${tag.content}" />`;
+  }).join("\n");
+}
+
+// src/core/generators/localbusiness.ts
+function generateLocalBusinessSchema(config) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": config.type || "LocalBusiness",
+    name: config.name,
+    image: config.image,
+    address: {
+      "@type": "PostalAddress",
+      ...config.address
+    },
+    ...config.url && { url: config.url },
+    ...config.telephone && { telephone: config.telephone },
+    ...config.priceRange && { priceRange: config.priceRange },
+    ...config.geo && {
+      geo: {
+        "@type": "GeoCoordinates",
+        latitude: config.geo.latitude,
+        longitude: config.geo.longitude
+      }
+    },
+    ...config.openingHours && {
+      openingHoursSpecification: Array.isArray(config.openingHours) ? config.openingHours.map((hours) => ({
+        "@type": "OpeningHoursSpecification",
+        ...hours
+      })) : {
+        "@type": "OpeningHoursSpecification",
+        ...config.openingHours
+      }
+    },
+    ...config.description && { description: config.description },
+    ...config.aggregateRating && {
+      aggregateRating: {
+        "@type": "AggregateRating",
+        ...config.aggregateRating
+      }
+    },
+    ...config.servesCuisine && { servesCuisine: config.servesCuisine },
+    ...config.menu && { menu: config.menu },
+    ...config.acceptsReservations !== void 0 && { acceptsReservations: config.acceptsReservations },
+    ...config.paymentAccepted && { paymentAccepted: config.paymentAccepted }
+  };
+  return LocalBusinessSchema.parse(schema);
+}
+
+// src/core/generators/event.ts
+function generateEventSchema(config) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": config.type || "Event",
+    name: config.name,
+    startDate: config.startDate,
+    ...config.endDate && { endDate: config.endDate },
+    ...config.eventStatus && { eventStatus: `https://schema.org/${config.eventStatus}` },
+    ...config.eventAttendanceMode && { eventAttendanceMode: `https://schema.org/${config.eventAttendanceMode}` },
+    ...config.location && {
+      location: typeof config.location === "string" ? config.location : {
+        "@type": "Place",
+        name: config.location.name,
+        ...config.location.address && {
+          address: typeof config.location.address === "string" ? config.location.address : {
+            "@type": "PostalAddress",
+            ...config.location.address
+          }
+        }
+      }
+    },
+    ...config.image && { image: config.image },
+    ...config.description && { description: config.description },
+    ...config.url && { url: config.url },
+    ...config.organizer && {
+      organizer: {
+        "@type": config.organizer.type,
+        name: config.organizer.name,
+        ...config.organizer.url && { url: config.organizer.url }
+      }
+    },
+    ...config.performer && {
+      performer: Array.isArray(config.performer) ? config.performer.map((p) => ({
+        "@type": p.type,
+        name: p.name
+      })) : {
+        "@type": config.performer.type,
+        name: config.performer.name
+      }
+    },
+    ...config.offers && {
+      offers: Array.isArray(config.offers) ? config.offers.map((offer) => ({
+        "@type": "Offer",
+        ...offer,
+        ...offer.availability && { availability: offer.availability }
+      })) : {
+        "@type": "Offer",
+        ...config.offers,
+        ...config.offers.availability && { availability: config.offers.availability }
+      }
+    }
+  };
+  return EventSchema.parse(schema);
+}
+
+// src/core/generators/webpage.ts
+function generateWebPageSchema(config) {
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    name: config.name,
+    description: config.description,
+    url: config.url,
+    ...config.inLanguage && { inLanguage: config.inLanguage },
+    ...config.isPartOf && { isPartOf: config.isPartOf },
+    ...config.breadcrumb && { breadcrumb: config.breadcrumb }
+  };
+  return WebPageSchema.parse(schema);
+}
+
+export { generateArticleSchema, generateBreadcrumbSchema, generateEventSchema, generateFAQSchema, generateIdentitySchema, generateLocalBusinessSchema, generateOpenGraphTags, generateOrganizationSchema, generatePersonSchema, generateProductSchema, generateScriptTag, generateSocialMetaTags, generateTwitterCardTags, generateWebPageSchema, metaTagsToHTML, serializeSchema };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map