0
# Creative Work Types
1

2
Schema.org types for creative content including articles, books, websites, media, software applications, and other intellectual works.
3

4
## Capabilities
5

6
### Creative Work Base Type
7

8
The root type for all creative works and intellectual content.
9

10
```typescript { .api }
11
/**
12
 * The most generic kind of creative work, including books, movies, photographs, 
13
 * software programs, etc.
14
 */
15
type CreativeWork = CreativeWorkLeaf | AmpStory | ArchiveComponent | Article |
16
  Atlas | Blog | Book | Certification | Chapter | Claim | Clip | Code |
17
  Collection | ComicStory | Comment | Conversation | Course |
18
  CreativeWorkSeason | CreativeWorkSeries | DataCatalog | Dataset |
19
  DefinedTermSet | Diet | DigitalDocument | Drawing |
20
  EducationalOccupationalCredential | Episode | ExercisePlan | Game |
21
  Guide | HowTo | HowToDirection | HowToSection | HowToStep | HowToTip |
22
  HyperToc | HyperTocEntry | LearningResource | Legislation | Manuscript |
23
  Map | MathSolver | MediaObject | MediaReviewItem | Menu | MenuSection |
24
  Message | Movie | MusicComposition | MusicPlaylist | MusicRecording |
25
  Painting | Photograph | Play | Poster | PublicationIssue |
26
  PublicationVolume | Quotation | Review | Sculpture | Season |
27
  SheetMusic | ShortStory | SoftwareApplication | SoftwareSourceCode |
28
  SpecialAnnouncement | Statement | Thesis | TVSeason | TVSeries |
29
  VisualArtwork | WebContent | WebPage | WebPageElement | WebSite;
30

31
interface CreativeWorkBase extends ThingBase {
32
  /** The subject matter of the content */
33
  about?: SchemaValue<Thing, "about">;
34
  /** Indicates that the resource is compatible with the referenced accessibility feature */
35
  accessibilityFeature?: SchemaValue<Text, "accessibilityFeature">;
36
  /** The human sensory perceptual system or cognitive faculty through which a person may process or perceive information */
37
  accessMode?: SchemaValue<Text, "accessMode">;
38
  /** A list of single or combined accessModes that are sufficient to understand all the intellectual content of a resource */
39
  accessModeSufficient?: SchemaValue<ItemList, "accessModeSufficient">;
40
  /** The author of this content or rating */
41
  author?: SchemaValue<Organization | Person, "author">;
42
  /** An award won by or for this item */
43
  award?: SchemaValue<Text, "award">;
44
  /** Fictional person connected with a creative work */
45
  character?: SchemaValue<Person, "character">;
46
  /** A citation or reference to another creative work */
47
  citation?: SchemaValue<CreativeWork | Text, "citation">;
48
  /** Comments, typically from users */
49
  comment?: SchemaValue<Comment, "comment">;
50
  /** The location depicted or described in the content */
51
  contentLocation?: SchemaValue<Place, "contentLocation">;
52
  /** Official rating of a piece of content */
53
  contentRating?: SchemaValue<Rating | Text, "contentRating">;
54
  /** The location where the CreativeWork was created */
55
  creativeWorkStatus?: SchemaValue<DefinedTerm | Text, "creativeWorkStatus">;
56
  /** The creator/author of this CreativeWork */
57
  creator?: SchemaValue<Organization | Person, "creator">;
58
  /** Date of first broadcast/publication */
59
  dateCreated?: SchemaValue<Date | DateTime, "dateCreated">;
60
  /** The date on which the CreativeWork was most recently modified */
61
  dateModified?: SchemaValue<Date | DateTime, "dateModified">;
62
  /** Date of first broadcast/publication */
63
  datePublished?: SchemaValue<Date | DateTime, "datePublished">;
64
  /** A secondary contributor to the CreativeWork */
65
  editor?: SchemaValue<Person, "editor">;
66
  /** Media type typically expressed using a MIME format */
67
  encodingFormat?: SchemaValue<Text | URL, "encodingFormat">;
68
  /** A creative work that this work is an example/instance/realization/derivation of */
69
  exampleOfWork?: SchemaValue<CreativeWork, "exampleOfWork">;
70
  /** Date the content expires and is no longer useful or available */
71
  expires?: SchemaValue<Date | DateTime, "expires">;
72
  /** Genre of the creative work, broadcast channel or group */
73
  genre?: SchemaValue<Text | URL, "genre">;
74
  /** Headlines of the article */
75
  headline?: SchemaValue<Text, "headline">;
76
  /** The language of the content or performance */
77
  inLanguage?: SchemaValue<Language | Text, "inLanguage">;
78
  /** Keywords or tags used to describe this content */
79
  keywords?: SchemaValue<DefinedTerm | Text | URL, "keywords">;
80
  /** A license document that applies to this content */
81
  license?: SchemaValue<CreativeWork | URL, "license">;
82
  /** The location where the CreativeWork was created */
83
  locationCreated?: SchemaValue<Place, "locationCreated">;
84
  /** Indicates the primary entity described in some page or other CreativeWork */
85
  mainEntity?: SchemaValue<Thing, "mainEntity">;
86
  /** The publisher of the creative work */
87
  publisher?: SchemaValue<Organization | Person, "publisher">;
88
  /** Date/DateTime the CreativeWork was published */
89
  publishingPrinciples?: SchemaValue<CreativeWork | URL, "publishingPrinciples">;
90
  /** The textual content of this CreativeWork */
91
  text?: SchemaValue<Text, "text">;
92
  /** Thumbnail image for an image or video */
93
  thumbnailUrl?: SchemaValue<URL, "thumbnailUrl">;
94
  /** The typical expected age range for the intended audience */
95
  typicalAgeRange?: SchemaValue<Text, "typicalAgeRange">;
96
  /** The version of the CreativeWork embodied by a specified resource */
97
  version?: SchemaValue<Number | Text, "version">;
98
}
99
```
100

101
### Article Types
102

103
Written content and news articles with various specializations.
104

105
```typescript { .api }
106
/**
107
 * An article, such as a news article or piece of investigative report
108
 */
109
type Article = ArticleLeaf | AdvertiserContentArticle | NewsArticle | Report |
110
  SatiricalArticle | ScholarlyArticle | SocialMediaPosting | TechArticle;
111

112
interface ArticleBase extends CreativeWorkBase {
113
  /** The number of words in the text of the Article */
114
  wordCount?: SchemaValue<Integer, "wordCount">;
115
  /** Articles may belong to one or more 'sections' in a magazine or newspaper */
116
  articleSection?: SchemaValue<Text, "articleSection">;
117
  /** For an Article, typically a NewsArticle, the dateline */
118
  dateline?: SchemaValue<Text, "dateline">;
119
}
120

121
/**
122
 * A NewsArticle is an article whose content reports news, or provides background context and supporting materials for understanding the news
123
 */
124
type NewsArticle = NewsArticleLeaf | AnalysisNewsArticle | AskPublicNewsArticle |
125
  BackgroundNewsArticle | OpinionNewsArticle | ReportageNewsArticle |
126
  ReviewNewsArticle;
127

128
/**
129
 * An Article whose content is primarily {@link https://schema.org/about about} a particular {@link https://schema.org/SoftwareApplication SoftwareApplication}, {@link https://schema.org/WebApplication WebApplication}, or {@link https://schema.org/MobileApplication MobileApplication}
130
 */
131
type TechArticle = TechArticleLeaf | APIReference;
132

133
/**
134
 * Reference documentation for application programming interfaces (APIs)
135
 */
136
type APIReference = APIReferenceLeaf;
137

138
interface APIReferenceBase extends TechArticleBase {
139
  /** Associated product/technology version. E.g., .NET Framework 4.5 */
140
  assemblyVersion?: SchemaValue<Text, "assemblyVersion">;
141
  /** Library file name, e.g., mscorlib.dll, system.web.dll */
142
  executableLibraryName?: SchemaValue<Text, "executableLibraryName">;
143
  /** Indicates whether API is managed or unmanaged */
144
  programmingModel?: SchemaValue<Text, "programmingModel">;
145
  /** Type of app development: phone, Metro style, desktop, XBox, etc. */
146
  targetPlatform?: SchemaValue<Text, "targetPlatform">;
147
}
148
```
149

150
**Usage Examples:**
151

152
```typescript
153
import type { Article, NewsArticle, TechArticle, APIReference } from "schema-dts";
154

155
// Basic article
156
const blogPost: Article = {
157
  "@type": "Article",
158
  headline: "Understanding TypeScript Generics",
159
  author: {
160
    "@type": "Person",
161
    name: "Jane Developer"
162
  },
163
  datePublished: "2024-01-15",
164
  articleSection: "Programming",
165
  wordCount: 1500,
166
  text: "TypeScript generics provide a way to create reusable components...",
167
  keywords: ["TypeScript", "Generics", "Programming"]
168
};
169

170
// News article
171
const newsStory: NewsArticle = {
172
  "@type": "NewsArticle",
173
  headline: "New Framework Released",
174
  dateline: "San Francisco, CA",
175
  author: {
176
    "@type": "Person",
177
    name: "Tech Reporter"
178
  },
179
  publisher: {
180
    "@type": "Organization",
181
    name: "Tech News Daily"
182
  },
183
  datePublished: "2024-01-20",
184
  articleSection: "Technology"
185
};
186

187
// API documentation
188
const apiDoc: APIReference = {
189
  "@type": "APIReference",
190
  headline: "Array.prototype.map() Method",
191
  about: {
192
    "@type": "SoftwareApplication",
193
    name: "JavaScript"
194
  },
195
  programmingModel: "JavaScript",
196
  targetPlatform: "Web Browsers, Node.js"
197
};
198
```
199

200
### Web Content Types
201

202
Types for web pages, websites, and web-specific content.
203

204
```typescript { .api }
205
/**
206
 * A web page. Every web page is implicitly assumed to be declared to be of type WebPage
207
 */
208
type WebPage = WebPageLeaf | AboutPage | CheckoutPage | CollectionPage |
209
  ContactPage | FAQPage | ItemPage | MedicalWebPage | ProfilePage | QAPage |
210
  RealEstateListing | SearchResultsPage;
211

212
interface WebPageBase extends CreativeWorkBase {
213
  /** A set of links that can help a user understand and navigate a website */
214
  breadcrumb?: SchemaValue<BreadcrumbList | Text, "breadcrumb">;
215
  /** Date when this media object was uploaded to this site */
216
  uploadDate?: SchemaValue<Date | DateTime, "uploadDate">;
217
  /** One of the more significant URLs on the page */
218
  significantLink?: SchemaValue<URL, "significantLink">;
219
  /** One of the domain specialists reviewing this content */
220
  reviewedBy?: SchemaValue<Organization | Person, "reviewedBy">;
221
  /** The most significant URLs on the page */
222
  mainContentOfPage?: SchemaValue<WebPageElement, "mainContentOfPage">;
223
  /** Indicates if use of the media require a subscription */
224
  requiresSubscription?: SchemaValue<Boolean | MediaSubscription, "requiresSubscription">;
225
  /** A link related to this web page */
226
  relatedLink?: SchemaValue<URL, "relatedLink">;
227
}
228

229
/**
230
 * A WebSite is a set of related web pages and other items typically served from a single web domain
231
 */
232
type WebSite = WebSiteLeaf;
233

234
interface WebSiteBase extends CreativeWorkBase {
235
  /** The entity that issues the credential */
236
  issuer?: SchemaValue<Organization, "issuer">;
237
}
238
```
239

240
**Usage Examples:**
241

242
```typescript
243
import type { WebPage, WebSite, AboutPage } from "schema-dts";
244

245
// Company website
246
const website: WebSite = {
247
  "@type": "WebSite",  
248
  name: "Acme Corp Website",
249
  url: "https://acme.com",
250
  publisher: {
251
    "@type": "Organization",
252
    name: "Acme Corporation"
253
  },
254
  inLanguage: "en-US"
255
};
256

257
// About page
258
const aboutPage: AboutPage = {
259
  "@type": "AboutPage",
260
  name: "About Us - Acme Corp",
261
  url: "https://acme.com/about",
262
  mainEntity: {
263
    "@type": "Organization",
264
    name: "Acme Corporation"
265
  },
266
  isPartOf: {
267
    "@type": "WebSite",
268
    name: "Acme Corp Website",
269
    url: "https://acme.com"
270
  },
271
  breadcrumb: {
272
    "@type": "BreadcrumbList",
273
    itemListElement: [
274
      {
275
        "@type": "ListItem",
276
        position: 1,
277
        name: "Home",
278
        item: "https://acme.com"
279
      },
280
      {
281
        "@type": "ListItem", 
282
        position: 2,
283
        name: "About",
284
        item: "https://acme.com/about"
285
      }
286
    ]
287
  }
288
};
289
```
290

291
### Software and Code Types
292

293
Types for software applications, source code, and development tools.
294

295
```typescript { .api }
296
/**
297
 * A software application
298
 */
299
type SoftwareApplication = SoftwareApplicationLeaf | GameApplication |
300
  MobileApplication | WebApplication;
301

302
interface SoftwareApplicationBase extends CreativeWorkBase {
303
  /** Type of software application, e.g. 'Game, Multimedia' */
304
  applicationCategory?: SchemaValue<Text | URL, "applicationCategory">;
305
  /** Subcategory of the application, e.g. 'Arcade Game' */
306
  applicationSubCategory?: SchemaValue<Text | URL, "applicationSubCategory">;
307
  /** The name of the application suite to which the application belongs */
308
  applicationSuite?: SchemaValue<Text, "applicationSuite">;
309
  /** Device required to run the application */
310
  availableOnDevice?: SchemaValue<Text, "availableOnDevice">;
311
  /** Countries for which the application is not supported */
312
  countriesNotSupported?: SchemaValue<Text, "countriesNotSupported">;
313
  /** Countries for which the application is supported */
314
  countriesSupported?: SchemaValue<Text, "countriesSupported">;
315
  /** Device required to run the application */
316
  device?: SchemaValue<Text, "device">;
317
  /** URL at which the app may be downloaded */
318
  downloadUrl?: SchemaValue<URL, "downloadUrl">;
319
  /** Features or modules provided by this application */
320
  featureList?: SchemaValue<Text | URL, "featureList">;
321
  /** Size of the application / package */
322
  fileSize?: SchemaValue<Text, "fileSize">;
323
  /** URL at which the app may be installed */
324
  installUrl?: SchemaValue<URL, "installUrl">;
325
  /** Minimum memory requirements */
326
  memoryRequirements?: SchemaValue<Text | URL, "memoryRequirements">;
327
  /** Operating systems supported */
328
  operatingSystem?: SchemaValue<Text, "operatingSystem">;
329
  /** Permission(s) required to run the app */
330
  permissions?: SchemaValue<Text, "permissions">;
331
  /** Processor architecture required to run the application */
332
  processorRequirements?: SchemaValue<Text, "processorRequirements">;
333
  /** Description of what changed in this version */
334
  releaseNotes?: SchemaValue<Text | URL, "releaseNotes">;
335
  /** Component dependency requirements for application */
336
  requirements?: SchemaValue<Text | URL, "requirements">;
337
  /** A link to a screenshot image of the app */
338
  screenshot?: SchemaValue<ImageObject | URL, "screenshot">;
339
  /** Version of the software instance */
340
  softwareVersion?: SchemaValue<Text, "softwareVersion">;
341
  /** Storage requirements (free space required) */
342
  storageRequirements?: SchemaValue<Text | URL, "storageRequirements">;
343
  /** Supporting data for a SoftwareApplication */
344
  supportingData?: SchemaValue<DataFeed, "supportingData">;
345
}
346

347
/**
348
 * Computer programming source code. Example: Full (compile ready) solutions, code snippet samples, scripts, templates
349
 */
350
type SoftwareSourceCode = SoftwareSourceCodeLeaf;
351

352
interface SoftwareSourceCodeBase extends CreativeWorkBase {
353
  /** Link to the repository where the un-compiled, human readable code and related code is located */
354
  codeRepository?: SchemaValue<URL, "codeRepository">;
355
  /** The computer programming language */
356
  programmingLanguage?: SchemaValue<ComputerLanguage | Text, "programmingLanguage">;
357
  /** Runtime platform or script interpreter dependencies */
358
  runtimePlatform?: SchemaValue<Text, "runtimePlatform">;
359
  /** What type of code sample: full (compile ready) solution, code snippet, inline code, scripts, template */
360
  codeSampleType?: SchemaValue<Text, "codeSampleType">;
361
  /** Target Operating System / Product to which the code applies */
362
  targetProduct?: SchemaValue<SoftwareApplication, "targetProduct">;
363
}
364
```
365

366
**Usage Examples:**
367

368
```typescript
369
import type { SoftwareApplication, SoftwareSourceCode, WebApplication } from "schema-dts";
370

371
// Software application
372
const textEditor: SoftwareApplication = {
373
  "@type": "SoftwareApplication",
374
  name: "CodeEdit Pro",
375
  applicationCategory: "DeveloperApplication",
376
  operatingSystem: ["Windows", "macOS", "Linux"],
377
  softwareVersion: "2.1.0",
378
  downloadUrl: "https://example.com/download",
379
  fileSize: "45MB",
380
  requirements: [
381
    "4GB RAM minimum",
382
    "500MB free disk space"
383
  ],
384
  featureList: [
385
    "Syntax highlighting",
386
    "Auto-completion", 
387
    "Git integration"
388
  ]
389
};
390

391
// Source code repository
392
const codeProject: SoftwareSourceCode = {
393
  "@type": "SoftwareSourceCode",  
394
  name: "React Todo App",
395
  programmingLanguage: "JavaScript",
396
  codeRepository: "https://github.com/user/react-todo",
397
  runtimePlatform: "Node.js",
398
  codeSampleType: "full solution",
399
  targetProduct: {
400
    "@type": "WebApplication",
401
    name: "Todo List Manager"
402
  },
403
  author: {
404
    "@type": "Person",
405
    name: "Developer Name"
406
  }
407
};
408
```
409

410
### Media Object Types
411

412
Types for images, videos, audio, and other media content.
413

414
```typescript { .api }
415
/**
416
 * A media object, such as an image, video, or audio object embedded in a web page or a downloadable dataset
417
 */
418
type MediaObject = MediaObjectLeaf | _3DModel | AudioObject | DataDownload |
419
  ImageObject | LegislationObject | MusicVideoObject | VideoObject;
420

421
interface MediaObjectBase extends CreativeWorkBase {
422
  /** A URL pointing to a player for a specific video */
423
  embedUrl?: SchemaValue<URL, "embedUrl">;
424
  /** Player type required—for example, Flash or Silverlight */
425
  playerType?: SchemaValue<Text, "playerType">;
426
  /** The production company or studio responsible for the item */
427
  productionCompany?: SchemaValue<Organization, "productionCompany">;
428
  /** Date when this media object was uploaded to this site */
429
  uploadDate?: SchemaValue<Date | DateTime, "uploadDate">;
430
  /** The width of the item */
431
  width?: SchemaValue<Distance | QuantitativeValue, "width">;
432
  /** The height of the item */
433
  height?: SchemaValue<Distance | QuantitativeValue, "height">;
434
  /** The duration of the item */
435
  duration?: SchemaValue<Duration, "duration">;
436
  /** A URL where a copy of the MediaObject can be found */
437
  contentUrl?: SchemaValue<URL, "contentUrl">;
438
  /** File size in MB */
439
  contentSize?: SchemaValue<Text, "contentSize">;
440
  /** Bitrate used to encode the media object, in bits per second */
441
  bitrate?: SchemaValue<Text, "bitrate">;
442
}
443

444
/**
445
 * An image file
446
 */
447
type ImageObject = ImageObjectLeaf | Barcode | ImageObjectSnapshot;
448

449
/**
450
 * A video file
451
 */
452
type VideoObject = VideoObjectLeaf | VideoObjectSnapshot;
453

454
/**
455
 * An audio file
456
 */
457
type AudioObject = AudioObjectLeaf | AudioObjectSnapshot;
458
```
459

460
**Usage Examples:**
461

462
```typescript
463
import type { ImageObject, VideoObject, AudioObject } from "schema-dts";
464

465
// Image with metadata
466
const productImage: ImageObject = {
467
  "@type": "ImageObject",
468
  contentUrl: "https://example.com/product.jpg",
469
  width: {
470
    "@type": "QuantitativeValue", 
471
    value: 800
472
  },
473
  height: {
474
    "@type": "QuantitativeValue",
475
    value: 600
476
  },
477
  encodingFormat: "image/jpeg",
478
  contentSize: "250KB",
479
  name: "Product Photo",
480
  caption: "High-quality product image"
481
};
482

483
// Video content
484
const tutorialVideo: VideoObject = {
485
  "@type": "VideoObject",
486
  name: "How to Use Our Software",
487
  contentUrl: "https://example.com/tutorial.mp4",
488
  embedUrl: "https://example.com/embed/tutorial",
489
  duration: "PT10M30S", // 10 minutes 30 seconds
490
  uploadDate: "2024-01-10",
491
  encodingFormat: "video/mp4",
492
  width: {
493
    "@type": "QuantitativeValue",
494
    value: 1920
495
  },
496
  height: {
497
    "@type": "QuantitativeValue", 
498
    value: 1080
499
  }
500
};
501
```