@chronicle.app/schema 0.1.0

package/LICENSE

@@ -0,0 +1,24 @@
+MIT License
+
+Copyright (c) 2026 Andrew Louis
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+This license covers the ontology (chronicle.ttl), generator, generated TypeScript
+and Zod schemas, and associated documentation.

package/README.md

@@ -0,0 +1,103 @@
+# @chronicle.app/schema
+
+A deliberately small extraction vocabulary with generated TypeScript interfaces
+and Zod validators. The canonical file is [chronicle.ttl](chronicle.ttl); edit it and run
+`npm run schema:generate` from the repository root. This generates both the
+TypeScript/Zod schemas and [the HTML reference](docs/schema.html).
+`npm run schema:check` verifies that both committed outputs match the ontology
+without rewriting them.
+
+Open `docs/schema.html` directly in a browser; its styles are embedded and it
+requires no server or network access. It includes hierarchy navigation, linked
+`:term` references, inherited properties, ranges, cardinality, and term URIs.
+Use `npm run generate:docs -w @chronicle.app/schema` to regenerate just the HTML.
+The package also exports the page as `@chronicle.app/schema/schema.html`.
+
+## Vocabulary
+
+- `Base`: an identity-bearing node; carries `sourceId`.
+- `Entity`: a thing described by a source; adds `name` and `url`.
+- `Action`: an occurrence; adds a single entity-valued `object`.
+
+Plugins extend these roots only where their outputs require it: Things adds task
+lifecycle actions and collections/tags; shell adds commands, people, and machine
+realms; iMessage adds messages and attachment media; Claude Code adds threads,
+software agents, and model instruments. Shared properties cover source identity,
+event time, agents, membership, authors, and recipients.
+
+`Text`, `URL`, and `DateTime` are literal datatypes. Properties remain optional;
+`chronicle.ttl` defines whether each is single-valued or a list. Records carry `@type` and at least one of `@key` (a nonempty list of
+identity fields or computed key entries) or `@id` (an existing identity).
+Identity validation checks that declaration, not the existence or hash of the
+referenced fields. Source-specific extraction owns the values; never invent IDs
+to make a record pass validation.
+
+```js
+import { ActionSchema, EntitySchema } from '@chronicle.app/schema';
+
+// Synthetic example data.
+const entity = EntitySchema.parse({
+  '@type': 'Entity',
+  '@key': ['sourceId'],
+  sourceId: 'example-record-1',
+  name: 'Example record',
+  url: 'https://example.com/record/1',
+});
+
+const action = ActionSchema.parse({
+  '@type': 'Action',
+  '@key': ['sourceId'],
+  sourceId: 'example-action-1',
+  object: entity,
+});
+```
+
+Each type has a `TypeSchema` validator and a `TypeAndChildrenSchema` validator
+that also accepts its descendants. `BaseAndChildrenSchema` accepts all declared
+record types. Validation checks nested identities, property types, URL syntax,
+and cardinality. Unknown object fields are stripped by Zod; undeclared record
+types are rejected. Import interfaces such as `Entity` and `Action` for static
+typing; use validators at runtime to enforce identity requirements.
+
+## Generation and compatibility
+
+The generator turns N3/Turtle into TypeScript types and Zod validators. It handles
+inheritance, domain/range, and OWL cardinality and fails for cyclic inheritance or
+undeclared referenced classes. The package has no persistence metadata, derived
+effects, or runtime filesystem parser.
+Generated runtime code depends only on Zod; the TTL is also included in the package.
+
+## Schema versions
+
+The npm package follows Chronicle’s shared software version in `package.json`.
+The ontology has an independent version declared with `owl:versionInfo` in
+`chronicle.ttl`, exported as the generated `SCHEMA_VERSION` constant. Software
+releases can advance without changing the vocabulary version.
+`chronicle.ttl` is the only editable ontology; historical versions are preserved
+by immutable software Git tags named `v<package-version>` and versioned npm packages.
+Release notes map software versions to vocabulary versions.
+The package exports `@chronicle.app/schema/chronicle.ttl`; the former
+`@chronicle.app/schema/schema.ttl` export remains an alias for compatibility.
+
+Use patch releases for description corrections that preserve meaning, minor
+releases for compatible vocabulary additions, and major releases for removed
+terms, changed meanings, or incompatible constraints. These compatibility rules
+also apply during `0.x`. Keep term identifiers such as
+`https://schema.chronicle.app/Task` stable; introduce a new term and deprecate the
+old one when its concept changes fundamentally.
+
+Snapshot paths use the vocabulary version, not the npm package version.
+The publication convention is
+`https://schema.chronicle.app/releases/<version>/chronicle.ttl`, with matching
+documentation under the same release path. Published snapshots must never be
+overwritten or removed by later deployments. The unversioned `/chronicle.ttl`
+and term pages should serve the latest released version, rather than unreleased
+changes on `main`. Website hosting is not configured yet; see
+[Preparing a release](../../RELEASING.md) for the release procedure.
+
+The vocabulary is intentionally small. Add terms only when a plugin needs them,
+keeping existing term identifiers and meanings stable; regenerate and add
+focused tests alongside each addition.
+
+Node.js 22.13+. MIT covers the ontology, generator, generated code, and docs;
+see [LICENSE](LICENSE).

package/chronicle.ttl

@@ -0,0 +1,198 @@
+# Chronicle's minimal extraction vocabulary. This is the canonical source.
+@prefix : <https://schema.chronicle.app/> .
+@prefix owl: <http://www.w3.org/2002/07/owl#> .
+@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> .
+
+: a owl:Ontology;
+  owl:versionInfo "0.1.0" .
+
+:Base a rdfs:Class;
+  rdfs:comment "The common base for entities and actions described by a source. Each node carries an identity, expressed as @key or @id, so it can be referenced across records." .
+:Entity a rdfs:Class;
+  rdfs:subClassOf :Base;
+  rdfs:comment "A thing described by a source, such as a person, place, document, or web page. An entity represents the thing itself; actions record what happened to or with it." .
+:Action a rdfs:Class;
+  rdfs:subClassOf :Base;
+  rdfs:comment "An occurrence recorded by a source, such as reading an article, sending a message, or visiting a place. Its :object identifies the entity the action was carried out on." .
+:Text a rdfs:Class;
+  rdfs:comment "A literal string, used for values such as names and source identifiers. Text is carried directly as a property value and has no node identity of its own." .
+:URL a rdfs:Class;
+  rdfs:comment "A Uniform Resource Locator expressed as an absolute URL string, such as https://example.com/article. Used for properties that locate a resource." .
+
+:sourceId a rdf:Property;
+  rdfs:comment "The identifier assigned by the source to an entity or action, such as a record ID or message ID. Represented as text and scoped to the source's own namespace; it need not be globally unique.";
+  owl:maxCardinality 1;
+  :domainIncludes :Base;
+  :rangeIncludes :Text .
+:name a rdf:Property;
+  rdfs:comment "The human-readable name or title of an entity, such as a person's display name, a document title, or a place name.";
+  owl:maxCardinality 1;
+  :domainIncludes :Entity;
+  :rangeIncludes :Text .
+:url a rdf:Property;
+  rdfs:comment "A URL at which the entity can be found, such as a web page's address or a link to a source record.";
+  owl:maxCardinality 1;
+  :domainIncludes :Entity;
+  :rangeIncludes :URL .
+:object a rdf:Property;
+  rdfs:comment "The entity an action is carried out on, such as the article being read, the message being sent, or the place being visited. For movement, the :object identifies where the movement began.";
+  owl:maxCardinality 1;
+  :domainIncludes :Action;
+  :rangeIncludes :Entity .
+
+:DateTime a rdfs:Class;
+  rdfs:comment "An instant anchored in time, including a date and time of day. Represented as a JavaScript Date in extracted records; use only when the source provides enough information to identify an instant." .
+:Agent a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "An entity capable of performing an action, such as a person, organization, or software agent. An action's :agent identifies its doer when known." .
+:Task a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "A unit of work to be done, such as a to-do item. The task carries its :name and :description; actions record its planning, updates, completion, or cancellation." .
+:Collection a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "A grouping of entities declared by a source, such as a list, an area of responsibility, or a section within a project. Members link to the collection through :isPartOf." .
+:Project a rdfs:Class;
+  rdfs:subClassOf :Collection;
+  rdfs:comment "An organized undertaking that groups related work toward an outcome. Tasks and other constituent entities link to the project through :isPartOf." .
+:Tag a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "A label used by a source to categorize or describe entities. Represented as an entity with its own identity so the same tag can be referenced by multiple records." .
+:PlanAction a rdfs:Class;
+  rdfs:subClassOf :Action;
+  rdfs:comment "The act of establishing an intention to do something, such as creating a to-do item. The :object identifies the planned work; the :timestamp records when the plan was made." .
+:UpdateAction a rdfs:Class;
+  rdfs:subClassOf :Action;
+  rdfs:comment "A change to an existing entity, such as editing a task's title or notes. The :object identifies the entity that was changed." .
+:CompleteAction a rdfs:Class;
+  rdfs:subClassOf :Action;
+  rdfs:comment "The completion of an activity or piece of work, such as finishing a task or a book. The :object identifies what was completed." .
+:CancelAction a rdfs:Class;
+  rdfs:subClassOf :Action;
+  rdfs:comment "The withdrawal of a plan or intended activity, such as cancelling a task. The :object identifies what was cancelled." .
+:DeleteAction a rdfs:Class;
+  rdfs:subClassOf :Action;
+  rdfs:comment "The removal of an entity from its source, including moving an item to the trash. The :object identifies what was removed." .
+:source a rdf:Property;
+  rdfs:comment "The source system that describes the entity or action, such as things-todo. Provides the source namespace in which identifiers such as :sourceId are interpreted.";
+  owl:maxCardinality 1;
+  :domainIncludes :Base;
+  :rangeIncludes :Text .
+:timestamp a rdf:Property;
+  rdfs:comment "The instant when the action occurred, as reported by the source. Records occurrence time, not the time Chronicle extracted the record.";
+  owl:maxCardinality 1;
+  :domainIncludes :Action;
+  :rangeIncludes :DateTime .
+:agent a rdf:Property;
+  rdfs:comment "The doer of the action, when identified by the source. Omit when no doer is known; an occurrence can be recorded without an agent.";
+  owl:maxCardinality 1;
+  :domainIncludes :Action;
+  :rangeIncludes :Agent .
+:sameAs a rdf:Property;
+  rdfs:comment "Another reference to the same entity, expressed as an entity node or a textual identity reference such as @me. Asserts shared identity, rather than similarity or association.";
+  :domainIncludes :Entity;
+  :rangeIncludes :Entity, :Text .
+:description a rdf:Property;
+  rdfs:comment "Descriptive text supplied by the source about an entity, such as a task's notes or a project's summary.";
+  owl:maxCardinality 1;
+  :domainIncludes :Entity;
+  :rangeIncludes :Text .
+:handle a rdf:Property;
+  rdfs:comment "A contextual identifier for an entity within its namespace, such as a username, channel slug, or tag label. Its meaning depends on the source or context in which it is used.";
+  owl:maxCardinality 1;
+  :domainIncludes :Entity;
+  :rangeIncludes :Text .
+:isPartOf a rdf:Property;
+  rdfs:comment "An entity that this entity forms part of, such as a task's project or collection, or the page containing an excerpt. Each value identifies a containing whole.";
+  :domainIncludes :Entity;
+  :rangeIncludes :Entity .
+:about a rdf:Property;
+  rdfs:comment "An entity representing the subject matter of this entity, such as a topic or tag describing what a task concerns.";
+  :domainIncludes :Entity;
+  :rangeIncludes :Entity .
+
+:Command a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "An instruction issued to a computer, such as a shell command. Its :body carries the command text; an :ExecuteAction records an execution of it." .
+:Person a rdfs:Class;
+  rdfs:subClassOf :Agent;
+  rdfs:comment "A human individual represented by a source, such as a message participant or computer user." .
+:Realm a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "A bounded account or computing domain, such as a workspace, computer system, or email domain. Agents belong to it through :memberOf; entities located within it use :inRealm." .
+:ExecuteAction a rdfs:Class;
+  rdfs:subClassOf :Action;
+  rdfs:comment "The execution of a command or software resource. The :object identifies what was executed; :agent identifies the doer when known." .
+:body a rdf:Property;
+  rdfs:comment "The textual content of an entity, such as a shell command or message, as supplied by the source.";
+  owl:maxCardinality 1;
+  :domainIncludes :Entity;
+  :rangeIncludes :Text .
+:memberOf a rdf:Property;
+  rdfs:comment "An entity the agent belongs to, such as a realm representing the computer system in which a user account exists.";
+  :domainIncludes :Agent;
+  :rangeIncludes :Entity .
+
+:Message a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "A communicated item, such as a text message or chat reply. Its :body carries text, :contains links attachments, and :recipient identifies the intended receivers." .
+:MessageAction a rdfs:Class;
+  rdfs:subClassOf :Action;
+  rdfs:comment "The sending of a message. The :object identifies the message and :agent identifies the sender when known." .
+:MediaObject a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "A media artifact, such as an image, audio recording, video, or document. Its :contentPath or :url locates the content, and :mimeType describes its format." .
+:ImageObject a rdfs:Class;
+  rdfs:subClassOf :MediaObject;
+  rdfs:comment "An image artifact, such as a photograph, screenshot, or image attachment." .
+:AudioObject a rdfs:Class;
+  rdfs:subClassOf :MediaObject;
+  rdfs:comment "An audio artifact, such as a voice message, music file, or sound recording." .
+:VideoObject a rdfs:Class;
+  rdfs:subClassOf :MediaObject;
+  rdfs:comment "A video artifact, such as a recorded clip or video attachment, which may include audio." .
+:DocumentObject a rdfs:Class;
+  rdfs:subClassOf :MediaObject;
+  rdfs:comment "A document artifact, such as a PDF, text file, or document attachment." .
+:recipient a rdf:Property;
+  rdfs:comment "An agent the message was directed to. A message can have multiple recipients, such as the other participants in a group conversation.";
+  :domainIncludes :Message;
+  :rangeIncludes :Agent .
+:contains a rdf:Property;
+  rdfs:comment "A media artifact carried by a message, such as an attached image, voice recording, video, or document.";
+  :domainIncludes :Message;
+  :rangeIncludes :MediaObject .
+:contentPath a rdf:Property;
+  rdfs:comment "An absolute filesystem path to the local file containing the media bytes. Describes where the extracted content is available on the source machine.";
+  owl:maxCardinality 1;
+  :domainIncludes :MediaObject;
+  :rangeIncludes :Text .
+:mimeType a rdf:Property;
+  rdfs:comment "The MIME type of the media content, such as image/jpeg, audio/mp4, or application/pdf.";
+  owl:maxCardinality 1;
+  :domainIncludes :MediaObject;
+  :rangeIncludes :Text .
+
+:SoftwareAgent a rdfs:Class;
+  rdfs:subClassOf :Agent;
+  rdfs:comment "Running software acting as a participant, such as an assistant, bot, or automation. It can be the :agent of an action or the :author of a message." .
+:SoftwareApplication a rdfs:Class;
+  rdfs:subClassOf :Entity;
+  rdfs:comment "A software application or model used to perform work. An action can identify it through :instrument, using the source-provided application or model identifier." .
+:Thread a rdfs:Class;
+  rdfs:subClassOf :Collection;
+  rdfs:comment "A conversation explicitly grouped by its source, such as an email thread or assistant chat. Messages link to it through :isPartOf; its :name can carry the conversation title." .
+:instrument a rdf:Property;
+  rdfs:comment "The tool, device, application, or model used to perform an action. The :agent identifies who acted; :instrument identifies what they used.";
+  owl:maxCardinality 1;
+  :domainIncludes :Action;
+  :rangeIncludes :Entity .
+:author a rdf:Property;
+  rdfs:comment "An agent that authored the message content, such as a person or software assistant.";
+  :domainIncludes :Message;
+  :rangeIncludes :Agent .
+:inRealm a rdf:Property;
+  rdfs:comment "The realm in which an entity resides, such as the computer system hosting a conversation or file. Provides context for identifiers that are local to that realm.";
+  owl:maxCardinality 1;
+  :domainIncludes :Entity;
+  :rangeIncludes :Realm .

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schema.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1 @@
+export * from './schema.js';

package/dist/schema.d.ts

@@ -0,0 +1,192 @@
+export declare const SCHEMA_VERSION: "0.1.0";
+import { z } from 'zod';
+export type KeyField = string | {
+    key: string;
+    value: string;
+};
+export interface Base {
+    '@type': 'Base';
+    source?: string;
+    sourceId?: string;
+    '@key'?: KeyField[];
+    '@id'?: string;
+}
+export type BaseAndChildren = Base | ActionAndChildren | EntityAndChildren;
+export declare const BaseSchema: z.ZodType<Base>;
+export interface Action extends Omit<Base, '@type'> {
+    '@type': 'Action';
+    agent?: AgentAndChildren;
+    instrument?: EntityAndChildren;
+    object?: EntityAndChildren;
+    timestamp?: Date;
+}
+export type ActionAndChildren = Action | CancelActionAndChildren | CompleteActionAndChildren | DeleteActionAndChildren | ExecuteActionAndChildren | MessageActionAndChildren | PlanActionAndChildren | UpdateActionAndChildren;
+export declare const ActionSchema: z.ZodType<Action>;
+export interface Entity extends Omit<Base, '@type'> {
+    '@type': 'Entity';
+    about?: EntityAndChildren[];
+    body?: string;
+    description?: string;
+    handle?: string;
+    inRealm?: RealmAndChildren;
+    isPartOf?: EntityAndChildren[];
+    name?: string;
+    sameAs?: (EntityAndChildren | string)[];
+    url?: string;
+}
+export type EntityAndChildren = Entity | AgentAndChildren | CollectionAndChildren | CommandAndChildren | MediaObjectAndChildren | MessageAndChildren | RealmAndChildren | SoftwareApplicationAndChildren | TagAndChildren | TaskAndChildren;
+export declare const EntitySchema: z.ZodType<Entity>;
+export interface Agent extends Omit<Entity, '@type'> {
+    '@type': 'Agent';
+    memberOf?: EntityAndChildren[];
+}
+export type AgentAndChildren = Agent | PersonAndChildren | SoftwareAgentAndChildren;
+export declare const AgentSchema: z.ZodType<Agent>;
+export interface MediaObject extends Omit<Entity, '@type'> {
+    '@type': 'MediaObject';
+    contentPath?: string;
+    mimeType?: string;
+}
+export type MediaObjectAndChildren = MediaObject | AudioObjectAndChildren | DocumentObjectAndChildren | ImageObjectAndChildren | VideoObjectAndChildren;
+export declare const MediaObjectSchema: z.ZodType<MediaObject>;
+export interface AudioObject extends Omit<MediaObject, '@type'> {
+    '@type': 'AudioObject';
+}
+export type AudioObjectAndChildren = AudioObject;
+export declare const AudioObjectSchema: z.ZodType<AudioObject>;
+export interface CancelAction extends Omit<Action, '@type'> {
+    '@type': 'CancelAction';
+}
+export type CancelActionAndChildren = CancelAction;
+export declare const CancelActionSchema: z.ZodType<CancelAction>;
+export interface Collection extends Omit<Entity, '@type'> {
+    '@type': 'Collection';
+}
+export type CollectionAndChildren = Collection | ProjectAndChildren | ThreadAndChildren;
+export declare const CollectionSchema: z.ZodType<Collection>;
+export interface Command extends Omit<Entity, '@type'> {
+    '@type': 'Command';
+}
+export type CommandAndChildren = Command;
+export declare const CommandSchema: z.ZodType<Command>;
+export interface CompleteAction extends Omit<Action, '@type'> {
+    '@type': 'CompleteAction';
+}
+export type CompleteActionAndChildren = CompleteAction;
+export declare const CompleteActionSchema: z.ZodType<CompleteAction>;
+export interface DeleteAction extends Omit<Action, '@type'> {
+    '@type': 'DeleteAction';
+}
+export type DeleteActionAndChildren = DeleteAction;
+export declare const DeleteActionSchema: z.ZodType<DeleteAction>;
+export interface DocumentObject extends Omit<MediaObject, '@type'> {
+    '@type': 'DocumentObject';
+}
+export type DocumentObjectAndChildren = DocumentObject;
+export declare const DocumentObjectSchema: z.ZodType<DocumentObject>;
+export interface ExecuteAction extends Omit<Action, '@type'> {
+    '@type': 'ExecuteAction';
+}
+export type ExecuteActionAndChildren = ExecuteAction;
+export declare const ExecuteActionSchema: z.ZodType<ExecuteAction>;
+export interface ImageObject extends Omit<MediaObject, '@type'> {
+    '@type': 'ImageObject';
+}
+export type ImageObjectAndChildren = ImageObject;
+export declare const ImageObjectSchema: z.ZodType<ImageObject>;
+export interface Message extends Omit<Entity, '@type'> {
+    '@type': 'Message';
+    author?: AgentAndChildren[];
+    contains?: MediaObjectAndChildren[];
+    recipient?: AgentAndChildren[];
+}
+export type MessageAndChildren = Message;
+export declare const MessageSchema: z.ZodType<Message>;
+export interface MessageAction extends Omit<Action, '@type'> {
+    '@type': 'MessageAction';
+}
+export type MessageActionAndChildren = MessageAction;
+export declare const MessageActionSchema: z.ZodType<MessageAction>;
+export interface Person extends Omit<Agent, '@type'> {
+    '@type': 'Person';
+}
+export type PersonAndChildren = Person;
+export declare const PersonSchema: z.ZodType<Person>;
+export interface PlanAction extends Omit<Action, '@type'> {
+    '@type': 'PlanAction';
+}
+export type PlanActionAndChildren = PlanAction;
+export declare const PlanActionSchema: z.ZodType<PlanAction>;
+export interface Project extends Omit<Collection, '@type'> {
+    '@type': 'Project';
+}
+export type ProjectAndChildren = Project;
+export declare const ProjectSchema: z.ZodType<Project>;
+export interface Realm extends Omit<Entity, '@type'> {
+    '@type': 'Realm';
+}
+export type RealmAndChildren = Realm;
+export declare const RealmSchema: z.ZodType<Realm>;
+export interface SoftwareAgent extends Omit<Agent, '@type'> {
+    '@type': 'SoftwareAgent';
+}
+export type SoftwareAgentAndChildren = SoftwareAgent;
+export declare const SoftwareAgentSchema: z.ZodType<SoftwareAgent>;
+export interface SoftwareApplication extends Omit<Entity, '@type'> {
+    '@type': 'SoftwareApplication';
+}
+export type SoftwareApplicationAndChildren = SoftwareApplication;
+export declare const SoftwareApplicationSchema: z.ZodType<SoftwareApplication>;
+export interface Tag extends Omit<Entity, '@type'> {
+    '@type': 'Tag';
+}
+export type TagAndChildren = Tag;
+export declare const TagSchema: z.ZodType<Tag>;
+export interface Task extends Omit<Entity, '@type'> {
+    '@type': 'Task';
+}
+export type TaskAndChildren = Task;
+export declare const TaskSchema: z.ZodType<Task>;
+export interface Thread extends Omit<Collection, '@type'> {
+    '@type': 'Thread';
+}
+export type ThreadAndChildren = Thread;
+export declare const ThreadSchema: z.ZodType<Thread>;
+export interface UpdateAction extends Omit<Action, '@type'> {
+    '@type': 'UpdateAction';
+}
+export type UpdateActionAndChildren = UpdateAction;
+export declare const UpdateActionSchema: z.ZodType<UpdateAction>;
+export interface VideoObject extends Omit<MediaObject, '@type'> {
+    '@type': 'VideoObject';
+}
+export type VideoObjectAndChildren = VideoObject;
+export declare const VideoObjectSchema: z.ZodType<VideoObject>;
+export declare const VideoObjectAndChildrenSchema: z.ZodType<VideoObject, z.ZodTypeDef, VideoObject>;
+export declare const UpdateActionAndChildrenSchema: z.ZodType<UpdateAction, z.ZodTypeDef, UpdateAction>;
+export declare const ThreadAndChildrenSchema: z.ZodType<Thread, z.ZodTypeDef, Thread>;
+export declare const TaskAndChildrenSchema: z.ZodType<Task, z.ZodTypeDef, Task>;
+export declare const TagAndChildrenSchema: z.ZodType<Tag, z.ZodTypeDef, Tag>;
+export declare const SoftwareApplicationAndChildrenSchema: z.ZodType<SoftwareApplication, z.ZodTypeDef, SoftwareApplication>;
+export declare const SoftwareAgentAndChildrenSchema: z.ZodType<SoftwareAgent, z.ZodTypeDef, SoftwareAgent>;
+export declare const RealmAndChildrenSchema: z.ZodType<Realm, z.ZodTypeDef, Realm>;
+export declare const ProjectAndChildrenSchema: z.ZodType<Project, z.ZodTypeDef, Project>;
+export declare const PlanActionAndChildrenSchema: z.ZodType<PlanAction, z.ZodTypeDef, PlanAction>;
+export declare const PersonAndChildrenSchema: z.ZodType<Person, z.ZodTypeDef, Person>;
+export declare const MessageActionAndChildrenSchema: z.ZodType<MessageAction, z.ZodTypeDef, MessageAction>;
+export declare const MessageAndChildrenSchema: z.ZodType<Message, z.ZodTypeDef, Message>;
+export declare const ImageObjectAndChildrenSchema: z.ZodType<ImageObject, z.ZodTypeDef, ImageObject>;
+export declare const ExecuteActionAndChildrenSchema: z.ZodType<ExecuteAction, z.ZodTypeDef, ExecuteAction>;
+export declare const DocumentObjectAndChildrenSchema: z.ZodType<DocumentObject, z.ZodTypeDef, DocumentObject>;
+export declare const DeleteActionAndChildrenSchema: z.ZodType<DeleteAction, z.ZodTypeDef, DeleteAction>;
+export declare const CompleteActionAndChildrenSchema: z.ZodType<CompleteAction, z.ZodTypeDef, CompleteAction>;
+export declare const CommandAndChildrenSchema: z.ZodType<Command, z.ZodTypeDef, Command>;
+export declare const CollectionAndChildrenSchema: z.ZodType<CollectionAndChildren>;
+export declare const CancelActionAndChildrenSchema: z.ZodType<CancelAction, z.ZodTypeDef, CancelAction>;
+export declare const AudioObjectAndChildrenSchema: z.ZodType<AudioObject, z.ZodTypeDef, AudioObject>;
+export declare const MediaObjectAndChildrenSchema: z.ZodType<MediaObjectAndChildren>;
+export declare const AgentAndChildrenSchema: z.ZodType<AgentAndChildren>;
+export declare const EntityAndChildrenSchema: z.ZodType<EntityAndChildren>;
+export declare const ActionAndChildrenSchema: z.ZodType<ActionAndChildren>;
+export declare const BaseAndChildrenSchema: z.ZodType<BaseAndChildren>;
+//# sourceMappingURL=schema.d.ts.map