@powerhousedao/knowledge-note 1.0.0

package/dist/document-models/knowledge-note/v1/gen/document-model.js

@@ -0,0 +1,393 @@
+export const documentModel = {
+    id: "bai/knowledge-note",
+    name: "KnowledgeNote",
+    author: {
+        name: "BAI",
+        website: "https://bai.dev",
+    },
+    extension: "",
+    description: "Atomic knowledge note \u2014 the building block of team-wide institutional memory. Notes have typed content, structured links, lifecycle states, and provenance tracking.",
+    specifications: [
+        {
+            state: {
+                local: {
+                    schema: "type KnowledgeNoteLocalState {\n    lastViewedAt: DateTime\n    personalTags: [PersonalTag!]!\n}\n\ntype PersonalTag {\n    id: OID!\n    name: String!\n}",
+                    examples: [],
+                    initialValue: '{\n    "lastViewedAt": null,\n    "personalTags": []\n}',
+                },
+                global: {
+                    schema: "enum NoteStatus {\n    DRAFT\n    IN_REVIEW\n    CANONICAL\n    ARCHIVED\n}\n\nenum SourceOrigin {\n    MANUAL\n    SESSION_MINE\n    IMPORT\n    DERIVED\n}\n\nenum LinkType {\n    RELATES_TO\n    BUILDS_ON\n    CONTRADICTS\n    SUPERSEDES\n    DERIVED_FROM\n}\n\ntype KnowledgeNoteState {\n    title: String\n    description: String\n    noteType: String\n    content: String\n    status: NoteStatus\n    provenance: Provenance\n    links: [NoteLink!]!\n    topics: [Topic!]!\n    scope: String\n    confidence: String\n    severity: String\n    editor: String\n    models: [String!]!\n    hooksUsed: [String!]!\n    dispatchTargets: [String!]!\n    modelId: String\n    modules: [String!]!\n    version: String\n    filePath: String\n    computes: String\n    inputs: [String!]!\n    outputs: [String!]!\n    consumedBy: [String!]!\n    context: String\n    alternatives: [String!]!\n    consequences: [String!]!\n    decisionStatus: String\n    model: String\n    sourceType: String\n    targetType: String\n    relationType: String\n    cardinality: String\n    errorMessage: String\n    rootCause: String\n    correctPattern: String\n    lifecycleEvents: [LifecycleEvent!]!\n}\n\ntype Provenance {\n    author: String\n    sourceOrigin: SourceOrigin\n    sessionId: String\n    createdAt: DateTime\n    updatedAt: DateTime\n}\n\ntype NoteLink {\n    id: OID!\n    targetDocumentId: String\n    targetTitle: String\n    linkType: LinkType\n}\n\ntype Topic {\n    id: OID!\n    name: String!\n    topicDocumentId: String\n}\n\ntype LifecycleEvent {\n    id: OID!\n    fromStatus: NoteStatus\n    toStatus: NoteStatus\n    actor: String\n    timestamp: DateTime\n    comment: String\n}",
+                    examples: [],
+                    initialValue: '{\n    "title": null,\n    "description": null,\n    "noteType": null,\n    "content": null,\n    "status": "DRAFT",\n    "provenance": null,\n    "links": [],\n    "topics": [],\n    "scope": null,\n    "confidence": null,\n    "severity": null,\n    "editor": null,\n    "models": [],\n    "hooksUsed": [],\n    "dispatchTargets": [],\n    "modelId": null,\n    "modules": [],\n    "version": null,\n    "filePath": null,\n    "computes": null,\n    "inputs": [],\n    "outputs": [],\n    "consumedBy": [],\n    "context": null,\n    "alternatives": [],\n    "consequences": [],\n    "decisionStatus": null,\n    "model": null,\n    "sourceType": null,\n    "targetType": null,\n    "relationType": null,\n    "cardinality": null,\n    "errorMessage": null,\n    "rootCause": null,\n    "correctPattern": null,\n    "lifecycleEvents": []\n}',
+                },
+            },
+            modules: [
+                {
+                    id: "content-module",
+                    name: "content",
+                    description: "Core note editing",
+                    operations: [
+                        {
+                            id: "set-title",
+                            name: "SET_TITLE",
+                            description: "Set the note title",
+                            schema: "input SetTitleInput {\n    title: String!\n    updatedAt: DateTime!\n}",
+                            template: "Set the note title",
+                            reducer: "state.title = action.input.title;\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.updatedAt;\n}",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "set-description",
+                            name: "SET_DESCRIPTION",
+                            description: "Set the note description (max 200 chars)",
+                            schema: "input SetDescriptionInput {\n    description: String!\n    updatedAt: DateTime!\n}",
+                            template: "Set the note description (max 200 chars)",
+                            reducer: 'if (action.input.description.length > 200) {\n    throw new DescriptionTooLongError("Description exceeds 200 characters");\n}\nstate.description = action.input.description;\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.updatedAt;\n}',
+                            errors: [
+                                {
+                                    id: "err-description-too-long",
+                                    name: "DescriptionTooLongError",
+                                    code: "DESCRIPTION_TOO_LONG",
+                                    description: "Description exceeds 200 characters",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "set-note-type",
+                            name: "SET_NOTE_TYPE",
+                            description: "Set or change the note type",
+                            schema: "input SetNoteTypeInput {\n    noteType: String!\n    updatedAt: DateTime!\n}",
+                            template: "Set or change the note type",
+                            reducer: "state.noteType = action.input.noteType;\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.updatedAt;\n}",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "set-content",
+                            name: "SET_CONTENT",
+                            description: "Replace the markdown content body",
+                            schema: "input SetContentInput {\n    content: String!\n    updatedAt: DateTime!\n}",
+                            template: "Replace the markdown content body",
+                            reducer: "state.content = action.input.content;\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.updatedAt;\n}",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "patch-content",
+                            name: "PATCH_CONTENT",
+                            description: "Surgical edit to content",
+                            schema: "input PatchContentInput {\n    offset: Int!\n    removeCount: Int!\n    insert: String!\n    updatedAt: DateTime!\n}",
+                            template: "Surgical edit to content",
+                            reducer: 'const content = state.content || "";\nconst { offset, removeCount, insert } = action.input;\nif (offset < 0 || offset + removeCount > content.length) {\n    throw new PatchOutOfBoundsError("Offset + removeCount exceeds content length");\n}\nstate.content = content.slice(0, offset) + insert + content.slice(offset + removeCount);\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.updatedAt;\n}',
+                            errors: [
+                                {
+                                    id: "err-patch-out-of-bounds",
+                                    name: "PatchOutOfBoundsError",
+                                    code: "PATCH_OUT_OF_BOUNDS",
+                                    description: "Offset + removeCount exceeds content length",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "set-metadata-field",
+                            name: "SET_METADATA_FIELD",
+                            description: "Set any string metadata field by name",
+                            schema: "input SetMetadataFieldInput {\n    field: String!\n    value: String\n    updatedAt: DateTime!\n}",
+                            template: "Set any string metadata field by name",
+                            reducer: 'const STRING_METADATA_FIELDS = [\n    "scope", "confidence", "severity", "editor", "modelId", "version",\n    "filePath", "computes", "context", "decisionStatus", "model",\n    "sourceType", "targetType", "relationType", "cardinality",\n    "errorMessage", "rootCause", "correctPattern"\n];\nconst { field, value } = action.input;\nif (!STRING_METADATA_FIELDS.includes(field)) {\n    throw new InvalidMetadataFieldError(`"${field}" is not a recognized string metadata field`);\n}\n(state as any)[field] = value || null;\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.updatedAt;\n}',
+                            errors: [
+                                {
+                                    id: "err-invalid-metadata-field",
+                                    name: "InvalidMetadataFieldError",
+                                    code: "INVALID_METADATA_FIELD",
+                                    description: "Field name is not a recognized string metadata field",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "set-metadata-list-field",
+                            name: "SET_METADATA_LIST_FIELD",
+                            description: "Set any string-array metadata field by name",
+                            schema: "input SetMetadataListFieldInput {\n    field: String!\n    values: [String!]!\n    updatedAt: DateTime!\n}",
+                            template: "Set any string-array metadata field by name",
+                            reducer: 'const LIST_METADATA_FIELDS = [\n    "models", "hooksUsed", "dispatchTargets", "modules", "inputs",\n    "outputs", "consumedBy", "alternatives", "consequences"\n];\nconst { field, values } = action.input;\nif (!LIST_METADATA_FIELDS.includes(field)) {\n    throw new InvalidMetadataListFieldError(`"${field}" is not a recognized list metadata field`);\n}\n(state as any)[field] = values;\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.updatedAt;\n}',
+                            errors: [
+                                {
+                                    id: "err-invalid-metadata-list-field",
+                                    name: "InvalidMetadataListFieldError",
+                                    code: "INVALID_METADATA_LIST_FIELD",
+                                    description: "Field name is not a recognized list metadata field",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                    ],
+                },
+                {
+                    id: "provenance-module",
+                    name: "provenance",
+                    description: "Source tracking",
+                    operations: [
+                        {
+                            id: "set-provenance",
+                            name: "SET_PROVENANCE",
+                            description: "Record author, source origin, session ID, and creation timestamp",
+                            schema: "input SetProvenanceInput {\n    author: String!\n    sourceOrigin: SourceOrigin!\n    sessionId: String\n    createdAt: DateTime!\n}",
+                            template: "Record author, source origin, session ID, and creation timestamp",
+                            reducer: "state.provenance = {\n    author: action.input.author,\n    sourceOrigin: action.input.sourceOrigin,\n    sessionId: action.input.sessionId || null,\n    createdAt: action.input.createdAt,\n    updatedAt: action.input.createdAt,\n};",
+                            errors: [],
+                            examples: [],
+                            scope: "global",
+                        },
+                    ],
+                },
+                {
+                    id: "linking-module",
+                    name: "linking",
+                    description: "Knowledge graph edges",
+                    operations: [
+                        {
+                            id: "add-link",
+                            name: "ADD_LINK",
+                            description: "Create a typed link to another note",
+                            schema: "input AddLinkInput {\n    id: OID!\n    targetDocumentId: String!\n    targetTitle: String\n    linkType: LinkType!\n}",
+                            template: "Create a typed link to another note",
+                            reducer: 'const existing = state.links.find(l => l.id === action.input.id);\nif (existing) {\n    throw new DuplicateLinkIdError("A link with this OID already exists");\n}\nstate.links.push({\n    id: action.input.id,\n    targetDocumentId: action.input.targetDocumentId,\n    targetTitle: action.input.targetTitle || null,\n    linkType: action.input.linkType,\n});',
+                            errors: [
+                                {
+                                    id: "err-duplicate-link-id",
+                                    name: "DuplicateLinkIdError",
+                                    code: "DUPLICATE_LINK_ID",
+                                    description: "A link with this OID already exists",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "remove-link",
+                            name: "REMOVE_LINK",
+                            description: "Remove a link by ID",
+                            schema: "input RemoveLinkInput {\n    id: OID!\n}",
+                            template: "Remove a link by ID",
+                            reducer: 'const index = state.links.findIndex(l => l.id === action.input.id);\nif (index === -1) {\n    throw new LinkNotFoundError("No link with this OID");\n}\nstate.links.splice(index, 1);',
+                            errors: [
+                                {
+                                    id: "err-link-not-found-remove",
+                                    name: "LinkNotFoundError",
+                                    code: "LINK_NOT_FOUND",
+                                    description: "No link with this OID",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "update-link-type",
+                            name: "UPDATE_LINK_TYPE",
+                            description: "Change a link's type",
+                            schema: "input UpdateLinkTypeInput {\n    id: OID!\n    linkType: LinkType!\n}",
+                            template: "Change a link's type",
+                            reducer: 'const link = state.links.find(l => l.id === action.input.id);\nif (!link) {\n    throw new LinkNotFoundError("No link with this OID");\n}\nlink.linkType = action.input.linkType;',
+                            errors: [
+                                {
+                                    id: "err-link-not-found-update",
+                                    name: "LinkNotFoundError",
+                                    code: "LINK_NOT_FOUND",
+                                    description: "No link with this OID",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "add-topic",
+                            name: "ADD_TOPIC",
+                            description: "Tag the note with a topic",
+                            schema: "input AddTopicInput {\n    id: OID!\n    name: String!\n    topicDocumentId: String\n}",
+                            template: "Tag the note with a topic",
+                            reducer: 'const duplicate = state.topics.find(t => t.name === action.input.name);\nif (duplicate) {\n    throw new DuplicateTopicError("A topic with this name already exists on this note");\n}\nstate.topics.push({\n    id: action.input.id,\n    name: action.input.name,\n    topicDocumentId: action.input.topicDocumentId || null,\n});',
+                            errors: [
+                                {
+                                    id: "err-duplicate-topic",
+                                    name: "DuplicateTopicError",
+                                    code: "DUPLICATE_TOPIC",
+                                    description: "A topic with this name already exists on this note",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "remove-topic",
+                            name: "REMOVE_TOPIC",
+                            description: "Remove a topic tag by ID",
+                            schema: "input RemoveTopicInput {\n    id: OID!\n}",
+                            template: "Remove a topic tag by ID",
+                            reducer: 'const index = state.topics.findIndex(t => t.id === action.input.id);\nif (index === -1) {\n    throw new TopicNotFoundError("No topic with this OID");\n}\nstate.topics.splice(index, 1);',
+                            errors: [
+                                {
+                                    id: "err-topic-not-found",
+                                    name: "TopicNotFoundError",
+                                    code: "TOPIC_NOT_FOUND",
+                                    description: "No topic with this OID",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                    ],
+                },
+                {
+                    id: "lifecycle-module",
+                    name: "lifecycle",
+                    description: "Status transitions with audit trail",
+                    operations: [
+                        {
+                            id: "submit-for-review",
+                            name: "SUBMIT_FOR_REVIEW",
+                            description: "Transition DRAFT \u2192 IN_REVIEW",
+                            schema: "input SubmitForReviewInput {\n    id: OID!\n    actor: String!\n    timestamp: DateTime!\n    comment: String\n}",
+                            template: "Transition DRAFT \u2192 IN_REVIEW",
+                            reducer: 'if (state.status !== "DRAFT") {\n    throw new InvalidStatusTransitionError("Can only submit for review from DRAFT status");\n}\nstate.status = "IN_REVIEW";\nstate.lifecycleEvents.push({\n    id: action.input.id,\n    fromStatus: "DRAFT",\n    toStatus: "IN_REVIEW",\n    actor: action.input.actor,\n    timestamp: action.input.timestamp,\n    comment: action.input.comment || null,\n});\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.timestamp;\n}',
+                            errors: [
+                                {
+                                    id: "err-invalid-transition-submit",
+                                    name: "InvalidStatusTransitionError",
+                                    code: "INVALID_STATUS_TRANSITION",
+                                    description: "Current status doesn't allow this transition",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "approve-note",
+                            name: "APPROVE_NOTE",
+                            description: "Transition IN_REVIEW \u2192 CANONICAL (actor \u2260 author)",
+                            schema: "input ApproveNoteInput {\n    id: OID!\n    actor: String!\n    timestamp: DateTime!\n    comment: String\n}",
+                            template: "Transition IN_REVIEW \u2192 CANONICAL (actor \u2260 author)",
+                            reducer: 'if (state.status !== "IN_REVIEW") {\n    throw new InvalidStatusTransitionError("Can only approve from IN_REVIEW status");\n}\nif (state.provenance && state.provenance.author === action.input.actor) {\n    throw new SelfApprovalError("Actor cannot approve their own note");\n}\nstate.status = "CANONICAL";\nstate.lifecycleEvents.push({\n    id: action.input.id,\n    fromStatus: "IN_REVIEW",\n    toStatus: "CANONICAL",\n    actor: action.input.actor,\n    timestamp: action.input.timestamp,\n    comment: action.input.comment || null,\n});\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.timestamp;\n}',
+                            errors: [
+                                {
+                                    id: "err-invalid-transition-approve",
+                                    name: "InvalidStatusTransitionError",
+                                    code: "INVALID_STATUS_TRANSITION",
+                                    description: "Current status doesn't allow this transition",
+                                    template: "",
+                                },
+                                {
+                                    id: "err-self-approval",
+                                    name: "SelfApprovalError",
+                                    code: "SELF_APPROVAL",
+                                    description: "Actor cannot approve their own note",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "reject-note",
+                            name: "REJECT_NOTE",
+                            description: "Transition IN_REVIEW \u2192 DRAFT with feedback",
+                            schema: "input RejectNoteInput {\n    id: OID!\n    actor: String!\n    timestamp: DateTime!\n    comment: String!\n}",
+                            template: "Transition IN_REVIEW \u2192 DRAFT with feedback",
+                            reducer: 'if (state.status !== "IN_REVIEW") {\n    throw new InvalidStatusTransitionError("Can only reject from IN_REVIEW status");\n}\nstate.status = "DRAFT";\nstate.lifecycleEvents.push({\n    id: action.input.id,\n    fromStatus: "IN_REVIEW",\n    toStatus: "DRAFT",\n    actor: action.input.actor,\n    timestamp: action.input.timestamp,\n    comment: action.input.comment,\n});\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.timestamp;\n}',
+                            errors: [
+                                {
+                                    id: "err-invalid-transition-reject",
+                                    name: "InvalidStatusTransitionError",
+                                    code: "INVALID_STATUS_TRANSITION",
+                                    description: "Current status doesn't allow this transition",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "archive-note",
+                            name: "ARCHIVE_NOTE",
+                            description: "Transition CANONICAL \u2192 ARCHIVED",
+                            schema: "input ArchiveNoteInput {\n    id: OID!\n    actor: String!\n    timestamp: DateTime!\n    comment: String!\n}",
+                            template: "Transition CANONICAL \u2192 ARCHIVED",
+                            reducer: 'if (state.status !== "CANONICAL") {\n    throw new InvalidStatusTransitionError("Can only archive from CANONICAL status");\n}\nstate.status = "ARCHIVED";\nstate.lifecycleEvents.push({\n    id: action.input.id,\n    fromStatus: "CANONICAL",\n    toStatus: "ARCHIVED",\n    actor: action.input.actor,\n    timestamp: action.input.timestamp,\n    comment: action.input.comment,\n});\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.timestamp;\n}',
+                            errors: [
+                                {
+                                    id: "err-invalid-transition-archive",
+                                    name: "InvalidStatusTransitionError",
+                                    code: "INVALID_STATUS_TRANSITION",
+                                    description: "Current status doesn't allow this transition",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                        {
+                            id: "restore-note",
+                            name: "RESTORE_NOTE",
+                            description: "Transition ARCHIVED \u2192 DRAFT",
+                            schema: "input RestoreNoteInput {\n    id: OID!\n    actor: String!\n    timestamp: DateTime!\n    comment: String\n}",
+                            template: "Transition ARCHIVED \u2192 DRAFT",
+                            reducer: 'if (state.status !== "ARCHIVED") {\n    throw new InvalidStatusTransitionError("Can only restore from ARCHIVED status");\n}\nstate.status = "DRAFT";\nstate.lifecycleEvents.push({\n    id: action.input.id,\n    fromStatus: "ARCHIVED",\n    toStatus: "DRAFT",\n    actor: action.input.actor,\n    timestamp: action.input.timestamp,\n    comment: action.input.comment || null,\n});\nif (state.provenance) {\n    state.provenance.updatedAt = action.input.timestamp;\n}',
+                            errors: [
+                                {
+                                    id: "err-invalid-transition-restore",
+                                    name: "InvalidStatusTransitionError",
+                                    code: "INVALID_STATUS_TRANSITION",
+                                    description: "Current status doesn't allow this transition",
+                                    template: "",
+                                },
+                            ],
+                            examples: [],
+                            scope: "global",
+                        },
+                    ],
+                },
+                {
+                    id: "local-module",
+                    name: "local",
+                    description: "Per-user local state",
+                    operations: [
+                        {
+                            id: "set-last-viewed",
+                            name: "SET_LAST_VIEWED",
+                            description: "Update the local lastViewedAt timestamp",
+                            schema: "input SetLastViewedInput {\n    lastViewedAt: DateTime!\n}",
+                            template: "Update the local lastViewedAt timestamp",
+                            reducer: "state.lastViewedAt = action.input.lastViewedAt;",
+                            errors: [],
+                            examples: [],
+                            scope: "local",
+                        },
+                    ],
+                },
+            ],
+            version: 1,
+            changeLog: [],
+        },
+    ],
+};

package/dist/document-models/knowledge-note/v1/gen/document-schema.d.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+import type { KnowledgeNoteDocument, KnowledgeNotePHState } from "./types.js";
+/** Schema for validating the header object of a KnowledgeNote document */
+export declare const KnowledgeNoteDocumentHeaderSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    createdAtUtcIso: z.ZodString;
+    lastModifiedAtUtcIso: z.ZodString;
+    documentType: z.ZodLiteral<"bai/knowledge-note">;
+}, z.core.$strip>;
+/** Schema for validating the state object of a KnowledgeNote document */
+export declare const KnowledgeNotePHStateSchema: z.ZodObject<{
+    global: z.ZodObject<Required<{
+        alternatives: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        cardinality: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        computes: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        confidence: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        consequences: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        consumedBy: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        content: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        context: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        correctPattern: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        decisionStatus: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        description: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        dispatchTargets: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        editor: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        errorMessage: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        filePath: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        hooksUsed: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        inputs: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        lifecycleEvents: z.ZodType<import("./types.js").LifecycleEvent[], unknown, z.core.$ZodTypeInternals<import("./types.js").LifecycleEvent[], unknown>>;
+        links: z.ZodType<import("./types.js").NoteLink[], unknown, z.core.$ZodTypeInternals<import("./types.js").NoteLink[], unknown>>;
+        model: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        modelId: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        models: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        modules: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        noteType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        outputs: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+        provenance: z.ZodType<import("./types.js").Maybe<import("./types.js").Provenance>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Provenance>, unknown>>;
+        relationType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        rootCause: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        scope: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        severity: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        sourceType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        status: z.ZodType<import("./types.js").Maybe<import("./types.js").NoteStatus>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").NoteStatus>, unknown>>;
+        targetType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        title: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        topics: z.ZodType<import("./types.js").Topic[], unknown, z.core.$ZodTypeInternals<import("./types.js").Topic[], unknown>>;
+        version: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+    }>, z.core.$strip>;
+}, z.core.$strip>;
+export declare const KnowledgeNoteDocumentSchema: z.ZodObject<{
+    header: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        createdAtUtcIso: z.ZodString;
+        lastModifiedAtUtcIso: z.ZodString;
+        documentType: z.ZodLiteral<"bai/knowledge-note">;
+    }, z.core.$strip>;
+    state: z.ZodObject<{
+        global: z.ZodObject<Required<{
+            alternatives: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            cardinality: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            computes: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            confidence: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            consequences: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            consumedBy: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            content: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            context: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            correctPattern: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            decisionStatus: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            description: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            dispatchTargets: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            editor: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            errorMessage: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            filePath: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            hooksUsed: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            inputs: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            lifecycleEvents: z.ZodType<import("./types.js").LifecycleEvent[], unknown, z.core.$ZodTypeInternals<import("./types.js").LifecycleEvent[], unknown>>;
+            links: z.ZodType<import("./types.js").NoteLink[], unknown, z.core.$ZodTypeInternals<import("./types.js").NoteLink[], unknown>>;
+            model: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            modelId: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            models: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            modules: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            noteType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            outputs: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            provenance: z.ZodType<import("./types.js").Maybe<import("./types.js").Provenance>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Provenance>, unknown>>;
+            relationType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            rootCause: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            scope: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            severity: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            sourceType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            status: z.ZodType<import("./types.js").Maybe<import("./types.js").NoteStatus>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").NoteStatus>, unknown>>;
+            targetType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            title: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            topics: z.ZodType<import("./types.js").Topic[], unknown, z.core.$ZodTypeInternals<import("./types.js").Topic[], unknown>>;
+            version: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        }>, z.core.$strip>;
+    }, z.core.$strip>;
+    initialState: z.ZodObject<{
+        global: z.ZodObject<Required<{
+            alternatives: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            cardinality: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            computes: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            confidence: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            consequences: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            consumedBy: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            content: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            context: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            correctPattern: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            decisionStatus: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            description: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            dispatchTargets: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            editor: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            errorMessage: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            filePath: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            hooksUsed: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            inputs: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            lifecycleEvents: z.ZodType<import("./types.js").LifecycleEvent[], unknown, z.core.$ZodTypeInternals<import("./types.js").LifecycleEvent[], unknown>>;
+            links: z.ZodType<import("./types.js").NoteLink[], unknown, z.core.$ZodTypeInternals<import("./types.js").NoteLink[], unknown>>;
+            model: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            modelId: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            models: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            modules: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            noteType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            outputs: z.ZodType<string[], unknown, z.core.$ZodTypeInternals<string[], unknown>>;
+            provenance: z.ZodType<import("./types.js").Maybe<import("./types.js").Provenance>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").Provenance>, unknown>>;
+            relationType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            rootCause: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            scope: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            severity: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            sourceType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            status: z.ZodType<import("./types.js").Maybe<import("./types.js").NoteStatus>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<import("./types.js").NoteStatus>, unknown>>;
+            targetType: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            title: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+            topics: z.ZodType<import("./types.js").Topic[], unknown, z.core.$ZodTypeInternals<import("./types.js").Topic[], unknown>>;
+            version: z.ZodType<import("./types.js").Maybe<string>, unknown, z.core.$ZodTypeInternals<import("./types.js").Maybe<string>, unknown>>;
+        }>, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Simple helper function to check if a state object is a KnowledgeNote document state object */
+export declare function isKnowledgeNoteState(state: unknown): state is KnowledgeNotePHState;
+/** Simple helper function to assert that a document state object is a KnowledgeNote document state object */
+export declare function assertIsKnowledgeNoteState(state: unknown): asserts state is KnowledgeNotePHState;
+/** Simple helper function to check if a document is a KnowledgeNote document */
+export declare function isKnowledgeNoteDocument(document: unknown): document is KnowledgeNoteDocument;
+/** Simple helper function to assert that a document is a KnowledgeNote document */
+export declare function assertIsKnowledgeNoteDocument(document: unknown): asserts document is KnowledgeNoteDocument;
+//# sourceMappingURL=document-schema.d.ts.map

package/dist/document-models/knowledge-note/v1/gen/document-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-schema.d.ts","sourceRoot":"","sources":["../../../../../document-models/knowledge-note/v1/gen/document-schema.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAE9E,0EAA0E;AAC1E,eAAO,MAAM,iCAAiC;;;;;;iBAG1C,CAAC;AAEL,yEAAyE;AACzE,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAErC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAItC,CAAC;AAEH,iGAAiG;AACjG,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,oBAAoB,CAE/B;AAED,6GAA6G;AAC7G,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,GACb,OAAO,CAAC,KAAK,IAAI,oBAAoB,CAEvC;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,OAAO,GAChB,QAAQ,IAAI,qBAAqB,CAEnC;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,OAAO,GAChB,OAAO,CAAC,QAAQ,IAAI,qBAAqB,CAE3C"}

package/dist/document-models/knowledge-note/v1/gen/document-schema.js

@@ -0,0 +1,33 @@
+import { BaseDocumentHeaderSchema, BaseDocumentStateSchema, } from "document-model";
+import { z } from "zod";
+import { knowledgeNoteDocumentType } from "./document-type.js";
+import { KnowledgeNoteStateSchema } from "./schema/zod.js";
+/** Schema for validating the header object of a KnowledgeNote document */
+export const KnowledgeNoteDocumentHeaderSchema = BaseDocumentHeaderSchema.extend({
+    documentType: z.literal(knowledgeNoteDocumentType),
+});
+/** Schema for validating the state object of a KnowledgeNote document */
+export const KnowledgeNotePHStateSchema = BaseDocumentStateSchema.extend({
+    global: KnowledgeNoteStateSchema(),
+});
+export const KnowledgeNoteDocumentSchema = z.object({
+    header: KnowledgeNoteDocumentHeaderSchema,
+    state: KnowledgeNotePHStateSchema,
+    initialState: KnowledgeNotePHStateSchema,
+});
+/** Simple helper function to check if a state object is a KnowledgeNote document state object */
+export function isKnowledgeNoteState(state) {
+    return KnowledgeNotePHStateSchema.safeParse(state).success;
+}
+/** Simple helper function to assert that a document state object is a KnowledgeNote document state object */
+export function assertIsKnowledgeNoteState(state) {
+    KnowledgeNotePHStateSchema.parse(state);
+}
+/** Simple helper function to check if a document is a KnowledgeNote document */
+export function isKnowledgeNoteDocument(document) {
+    return KnowledgeNoteDocumentSchema.safeParse(document).success;
+}
+/** Simple helper function to assert that a document is a KnowledgeNote document */
+export function assertIsKnowledgeNoteDocument(document) {
+    KnowledgeNoteDocumentSchema.parse(document);
+}

package/dist/document-models/knowledge-note/v1/gen/document-type.d.ts

@@ -0,0 +1,2 @@
+export declare const knowledgeNoteDocumentType = "bai/knowledge-note";
+//# sourceMappingURL=document-type.d.ts.map

package/dist/document-models/knowledge-note/v1/gen/document-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-type.d.ts","sourceRoot":"","sources":["../../../../../document-models/knowledge-note/v1/gen/document-type.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB,uBAAuB,CAAC"}

package/dist/document-models/knowledge-note/v1/gen/document-type.js

@@ -0,0 +1 @@
+export const knowledgeNoteDocumentType = "bai/knowledge-note";