Generate valid, production-ready JSON-LD structured data markup for any page type, including all required and recommended schema.org properties, properly formatted for direct implementation into the page source code.

SCHEMA MARKUP GENERATION PROCESS:

1. Schema Type Selection
   - Based on the provided page type and content, select the most appropriate primary schema type:
     * Organization: Company homepages, about pages
     * LocalBusiness (or specific subtype): Local business homepages, location pages
     * Article / BlogPosting / NewsArticle: Blog posts, news articles, editorial content
     * Product: Individual product pages with pricing and availability
     * FAQPage: Pages with question-and-answer content
     * HowTo: Tutorial or instructional pages with step-by-step processes
     * Event: Event listing or detail pages
     * BreadcrumbList: Any page (supplementary navigation markup)
     * WebSite: Homepage (for sitelinks search box)
     * Person: Author pages, team member pages
     * Course: Online course or educational program pages
     * Recipe: Recipe content pages
     * VideoObject: Pages featuring video content
     * SoftwareApplication: App or software product pages
   - If multiple schema types apply to a single page, generate each as a separate script block or use @graph notation
   - Identify any nested types needed (e.g., Product contains Offer contains PriceSpecification)

2. Required Properties Completion
   - For every selected schema type, include ALL required properties as specified by Google's structured data documentation
   - Fill in every required property with either:
     * The actual value provided by the user
     * A clearly marked placeholder: [YOUR_VALUE_HERE] with a description of what to insert
   - Never omit a required property -- missing required properties will cause validation failures
   - Cross-reference requirements against both schema.org specifications and Google's rich result requirements (these sometimes differ)

3. Recommended Properties Enhancement
   - Beyond required properties, include ALL recommended properties that enhance rich result eligibility
   - For each recommended property, note whether it is:
     * Strongly recommended (significantly impacts rich result display)
     * Optional but beneficial (adds context for search engines)
   - Common recommended properties to always consider:
     * image (with proper ImageObject nesting when appropriate)
     * description
     * url
     * datePublished / dateModified (for time-sensitive content)
     * author (with proper Person or Organization nesting)
     * aggregateRating / review (when applicable)
     * sameAs (for social profiles and authoritative references)

4. Nested Schema and Relationships
   - Properly nest related schema types rather than flattening them
   - For example, a Product should contain Offer, which contains PriceSpecification, which contains the price and currency
   - Use @id references for entities that appear in multiple places on the same page
   - Ensure all nested types have their own required and recommended properties filled in
   - Include BreadcrumbList markup alongside the primary schema when the page has breadcrumb navigation

5. Validation and Best Practices
   - Ensure all JSON syntax is correct: proper comma placement, quote escaping, no trailing commas
   - Use the correct @context: "https://schema.org"
   - Use ISO 8601 format for all date properties (YYYY-MM-DD or YYYY-MM-DDTHH:MM:SS+00:00)
   - Use ISO 4217 format for currency codes (USD, EUR, GBP)
   - Ensure URLs are absolute, not relative
   - Avoid markup that represents content not visible to users (this violates Google's guidelines)
   - Include only one FAQPage per page, but multiple Questions within it
   - Keep description lengths reasonable (under 300 characters for most types)

6. Implementation Instructions
   - Specify exactly where to place the script tag in the page HTML (head vs body, and why)
   - Provide testing instructions using Google's Rich Results Test
   - Note which rich result type this markup is eligible to trigger
   - Include any CMS-specific implementation notes if the platform is specified
   - List common implementation mistakes to avoid for the selected schema type

OUTPUT CONSTRAINTS:
- All JSON-LD must be syntactically valid (parseable by any JSON parser)
- Include every required property for Google rich result eligibility
- Mark all placeholder values clearly with [BRACKETS] and descriptions
- Include comments (outside the JSON, as implementation notes) explaining non-obvious property choices
- Provide the complete script tag wrapper, not just the JSON object
- Test that the generated code would pass Google's Rich Results Test

FORMAT:

**SCHEMA TYPE:** [Primary schema type]
**RICH RESULT ELIGIBILITY:** [Which Google rich result this enables]
**PLACEMENT:** [Where to add in HTML -- head or body]

**IMPLEMENTATION CODE:**
```html
<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "[Type]",
  [all properties]
}
</script>
```

**PROPERTY REFERENCE:**
| Property | Value | Required/Recommended | Notes |
|----------|-------|---------------------|-------|

**PLACEHOLDER VALUES TO REPLACE:**
| Placeholder | Description | Example |
|-------------|-------------|---------|

**SUPPLEMENTARY SCHEMA (if applicable):**
[BreadcrumbList or other supporting schema with full code]

**TESTING CHECKLIST:**
- [ ] Paste code into Google Rich Results Test
- [ ] Verify no errors on required properties
- [ ] Check warnings on recommended properties
- [ ] Validate JSON syntax at jsonlint.com
- [ ] Verify all URLs are absolute and accessible
- [ ] Confirm all dates use ISO 8601 format

**COMMON MISTAKES TO AVOID:**
[List of 3-5 type-specific implementation pitfalls]

---

MY INFO:

Page Type (product, article, FAQ, local business, event, how-to, etc.): (required)
Page URL: (required)
Page Content Summary or Key Details: (required)
Business/Organization Name: (optional)
CMS Platform: (optional)
Existing Schema Markup on the Page: (optional)
Specific Rich Result Goal: (optional)
Multiple Schema Types Needed (yes/no): (optional)