ThingBase is not exported about schema-dts

[Eyas]

I wrote up an explanation here about the structure of the type system, but basically, we have something like:

declare type ThingBase = {
    "additionalType"?: URL | URL[];
    "alternateName"?: Text | Text[];
   // ...
};

// This is conceptually true but in practice, it is inlined:
export declare type ThingLeaf = {
    "@type": "Thing";
} & ThingBase;

export declare type Thing = ThingLeaf | Action | CreativeWork | Event | Intangible | MedicalEntity | Organization | Person | Place | Product /* | ... */;

So Thing itself is not just ThingLeaf, but any subsequent child type. The discriminated unions progress recursively to cover all Schema.org types. e.g.

export declare type Organization = OrganizationLeaf | Airline | Consortium | Corporation | EducationalOrganization | FundingScheme | GovernmentOrganization | LibrarySystem | LocalBusiness | MedicalOrganization | NewsMediaOrganization | NGO | PerformingGroup | Project | SportsOrganization | WorkersUnion;

... and so on.

Under the current type system, Person is part of Thing's union, and thus it extends it.

You can try it out with WithContext, which is supplied by schema-dts and you can import it. It's written as such:

export declare type WithContext<T extends Thing> = T & {
    "@context": "https://schema.org";
};

With that, you can write things like:

import { Person, WithContext } from "schema-dts";

const t: WithContext<Person> = {
  "@context": "https://schema.org",
  "@type": "Person", // "Patient" also works here
  "name": "happy"
};

[Eyas]

#28 suggested another use-case where something that looks like this.

My general concern with exporting intermediate types is just that it ties up future development. Right now the API boundary is just the final types (Thing, Person, etc.) and everything in between can change in a breaking way.

As schema-dts matures, I'll be more and more comfortable doing this. Worth looking at this now.

I'm curious, though, why not just use Thing here? It seems like it should just work if WithId was defined as:

export type WithId<T extends Thing> = T & Identified;

That's what we do when we define WithContext right now.

[rosskevin]

But for example Person and Organization do not extend Thing...so how could that be correct?