@segmentstream-cloud/ontology 0.6.0 → 0.8.0

package/README.md

@@ -8,6 +8,14 @@ database and the HTTP service under `/api/ontology`. Every read and every action
 a permission that the caller's roles grant, and every change to a record goes through an
 action and is kept in history.
 
+TypeScript definitions, handler records and SDK calls use camelCase: `jobTitle`,
+`assignedOwnerId`, `createdAt`, and `changeStatus`. The SDK converts ontology names,
+select identifiers and declared action input fields to snake_case for the generated
+REST API, version 4 manifest and storage. TypeScript helpers and options stay
+camelCase. JSON property contents, provider payloads, opaque action results and
+historical change names remain data and are preserved. `formatManifest` serializes
+the canonical wire contract shared by REST, storage and future transports.
+
 ## Install
 
 ```sh
@@ -121,7 +129,7 @@ entity, the verb or both: `lead:*`, `*:read`, `*:*`.
 - Reads require `<entity>:read`: lists, queries, records, history, and both entities of a
   relationship traversal. `include` and a filter through a relationship require `read` on
   the related entity. A missing permission answers 403 with `<permission> is required.`
-- Each action requires one permission. The generated `upsertBy<Property>` requires both
+- Each action requires one permission. The generated `upsert_by_<property>` requires both
   `<entity>:create` and `<entity>:update`.
 - A principal's permissions are the union of its roles' permissions in the ontology.
   Members hold `member` and their assigned roles; an API key holds exactly the roles it was
@@ -182,7 +190,7 @@ Sign-in finds the user linked to the token's provider and subject, else links th
 invited with the same email, else follows the ontology's `signIn` policy: `invited` answers
 403 `{ "error": "not_invited", "detail": "Ask your administrator for an invitation." }`,
 `open` creates a member. Deactivated members are refused. Each sign-in sets the user's
-`lastSignInAt`, at most once per 15 minutes, so the user's history records it.
+`last_sign_in_at`, at most once per 15 minutes, so the user's history records it.
 
 `GET /api/ontology/me` answers who the caller is, for the app to render what they may do:
 `{ user: { id, name, email, kind, active }, roles, permissions }`. It needs only
@@ -234,3 +242,7 @@ usage error.
 ## License
 
 Apache-2.0
+
+## Entity sources and aggregates
+
+Entities with a warehouse source declare mapped properties and measures without storage tables or record operations. See [ontology aggregates](../../docs/ontology-aggregates.md) for declaration rules, source verification, workspace authorization and the overlap release.

package/dist/analyze.js

@@ -3,14 +3,16 @@ import { Schema } from "effect";
 import { isAction } from "./action.js";
 import { CONNECTION_KEY, isConnection } from "./connection.js";
 import { isEntity } from "./entity.js";
-import { CAMEL_CASE_NAME, ENTITY_ID, GENERATED_ACTIONS, GENERATED_UPSERT_PREFIX, HISTORY_SUFFIX, MEMBER_ROLE, RESERVED_ENTITY_NAMES, RESERVED_MEMBER_NAMES, RESERVED_RELATIONSHIP_NAMES, SNAKE_CASE_NAME, SYSTEM_PROPERTIES, isSystemProperty, } from "./names.js";
+import { LEGACY_MEMBER_NAME, ENTITY_ID, GENERATED_ACTIONS, GENERATED_UPSERT_PREFIX, HISTORY_SUFFIX, MEMBER_ROLE, RESERVED_ENTITY_NAMES, RESERVED_MEMBER_NAMES, RESERVED_RELATIONSHIP_NAMES, SNAKE_CASE_NAME, SYSTEM_PROPERTIES, isSystemProperty, } from "./names.js";
 import { REFERENCE_ANNOTATION, propertyDefinition, referenceTarget, } from "./property.js";
 import { generatedActionPermissions, parsePermission, permissionOf, READ_VERB, rolesGranting, WILDCARD, } from "./permissions.js";
 import { ON_DELETE, isRelationship } from "./relationship.js";
 import { isRole, member, role } from "./role.js";
 import { DEFAULT_SIGN_IN_POLICY, isSignInPolicy } from "./sign-in.js";
 import { User } from "./user.js";
-const GENERATED_UPSERT = new RegExp(`^${GENERATED_UPSERT_PREFIX}[A-Z]`);
+import { authoringToWire } from "./authoring.js";
+import { nameToWire } from "./authoring-names.js";
+const GENERATED_UPSERT = new RegExp(`^${GENERATED_UPSERT_PREFIX}`);
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -29,7 +31,10 @@ export function analyze(config, options = {}) {
     const report = (code, path, message, severity = "error") => {
         diagnostics.push({ severity, code, path, message });
     };
-    const user = options.user ?? User;
+    const original = config;
+    const normalized = authoringToWire(config, options.user ?? User, report);
+    config = normalized.config;
+    const user = normalized.user;
     const entities = collectEntities(config, user, report);
     const roles = collectRoles(config, report);
     const signIn = signInOptions(config, report);
@@ -45,7 +50,7 @@ export function analyze(config, options = {}) {
         user,
         entitiesByName,
         definitions: new Set(entities.map((candidate) => candidate.definition)),
-        entityProperties: new Set(entities.flatMap((candidate) => Object.values(candidate.definition.properties ?? {}))),
+        entityProperties: new Set([...entities, ...(original.entities ?? []).filter(isEntity)].flatMap((candidate) => Object.values(candidate.definition.properties ?? {}))),
         connections: new Set(connections.map((candidate) => candidate.key)),
     };
     const resolved = entities.map((candidate) => resolveEntity(candidate, scope));
@@ -293,8 +298,8 @@ function entityPermissions(name, builtIn, relationships) {
     };
 }
 function checkMemberName(kind, path, name, report) {
-    if (!CAMEL_CASE_NAME.test(name)) {
-        report("invalid-name", path, `${kind} names are lower camelCase, for example ownedLeads.`);
+    if (!SNAKE_CASE_NAME.test(name)) {
+        report("invalid-name", path, `${kind} names are lowercase snake_case, for example owned_leads.`);
     }
     else if (isSystemProperty(name)) {
         report("reserved-name", path, `${name} is a system property of every entity.`);
@@ -314,7 +319,10 @@ function resolveProperties(candidate, scope) {
     const properties = [];
     for (const [name, schema] of entries) {
         const path = `${candidate.name}.properties.${name}`;
-        const definition = propertyDefinition(schema);
+        const originalDefinition = propertyDefinition(schema);
+        const definition = !Array.isArray(originalDefinition?.scope)
+            ? originalDefinition
+            : { ...originalDefinition, scope: originalDefinition.scope.map(nameToWire) };
         checkMemberName("property", path, name, report);
         if (definition === undefined) {
             const hint = referenceTarget(schema) === undefined
@@ -325,7 +333,7 @@ function resolveProperties(candidate, scope) {
         }
         checkProperty(path, schema, definition, report);
         if (definition.renamedFrom !== undefined) {
-            checkRenamedFrom(path, name, definition.renamedFrom, names, CAMEL_CASE_NAME, report);
+            checkRenamedFrom(path, name, definition.renamedFrom, names, LEGACY_MEMBER_NAME, report);
         }
         properties.push({ name, schema: schema, definition });
     }
@@ -356,8 +364,8 @@ function checkSelectOptions(path, definition, report) {
     }
     options.forEach((option, index) => {
         const optionPath = `${path}.options[${index}]`;
-        if (isBlank(option.value)) {
-            report("invalid-options", optionPath, "option values cannot be empty.");
+        if (!SNAKE_CASE_NAME.test(option.value)) {
+            report("invalid-options", optionPath, "option values must be lowercase snake_case.");
         }
         else if (seen.has(option.value)) {
             report("invalid-options", optionPath, `the option value "${option.value}" is listed twice.`);
@@ -500,8 +508,8 @@ function resolveActions(candidate, scope) {
     const actions = [];
     for (const [name, action] of actionEntries(candidate, report)) {
         const path = `${candidate.name}.actions.${name}`;
-        if (!CAMEL_CASE_NAME.test(name)) {
-            report("invalid-name", path, "action names are lower camelCase, for example changeStatus.");
+        if (!SNAKE_CASE_NAME.test(name)) {
+            report("invalid-name", path, "action names are lowercase snake_case, for example change_status.");
         }
         else if (GENERATED_ACTIONS.includes(name) ||
             GENERATED_UPSERT.test(name)) {
@@ -546,17 +554,23 @@ function resolvePermission(path, fallback, action, scope) {
 }
 function resolveInput(path, input, scope) {
     const inputPath = `${path}.input`;
-    if (!Schema.isSchema(input) || input.ast._tag !== "Objects" || !("fields" in input)) {
+    if (!Schema.isSchema(input) || Schema.toEncoded(input).ast._tag !== "Objects") {
         scope.report("invalid-action-input", inputPath, "must be a Schema.Struct of the action's inputs.");
         return undefined;
     }
-    checkInputFields(inputPath, input.fields, scope);
+    if ("fields" in input) {
+        checkInputFields(inputPath, input.fields, scope);
+    }
     try {
         const document = Schema.toJsonSchemaDocument(input, {
             includeAnnotationKey: (key) => key === REFERENCE_ANNOTATION,
             onExcessProperty: "error",
         });
         const schema = document.schema;
+        checkEncodedInputNames(schema, inputPath, scope, !("fields" in input));
+        for (const definition of Object.values(document.definitions)) {
+            checkEncodedInputNames(definition, inputPath, scope, !("fields" in input));
+        }
         return Object.keys(document.definitions).length === 0
             ? schema
             : { ...schema, $defs: document.definitions };
@@ -566,11 +580,38 @@ function resolveInput(path, input, scope) {
         return undefined;
     }
 }
+/** Check named input fields on the wire side; codecs may decode them to camelCase handler values. */
+function checkEncodedInputNames(schema, path, scope, checkReferences) {
+    const { report } = scope;
+    const reference = schema[REFERENCE_ANNOTATION];
+    if (checkReferences && typeof reference === "string" && !scope.entitiesByName.has(reference)) {
+        report("unknown-reference", path, `references "${reference}", which is not an entity of this ontology.`);
+    }
+    const properties = schema.properties;
+    if (properties !== null && typeof properties === "object" && !Array.isArray(properties)) {
+        for (const [name, child] of Object.entries(properties)) {
+            if (!SNAKE_CASE_NAME.test(name)) {
+                report("invalid-name", `${path}.${name}`, "action input names are lowercase snake_case.");
+            }
+            if (child !== null && typeof child === "object" && !Array.isArray(child)) {
+                checkEncodedInputNames(child, `${path}.${name}`, scope, checkReferences);
+            }
+        }
+    }
+    for (const key of ["items", "additionalProperties", "anyOf", "oneOf", "allOf"]) {
+        const children = schema[key];
+        for (const child of Array.isArray(children) ? children : [children]) {
+            if (child !== null && typeof child === "object" && !Array.isArray(child)) {
+                checkEncodedInputNames(child, path, scope, checkReferences);
+            }
+        }
+    }
+}
 function checkInputFields(path, fields, scope) {
     for (const [name, field] of Object.entries(fields)) {
         const fieldPath = `${path}.${name}`;
         const reference = referenceTarget(field);
-        if (reference !== undefined && !scope.entitiesByName.has(reference)) {
+        if (reference !== undefined && !scope.entitiesByName.has(nameToWire(reference))) {
             scope.report("unknown-reference", fieldPath, `references "${reference}", which is not an entity of this ontology.`);
         }
         if (scope.entityProperties.has(field)) {
@@ -621,7 +662,7 @@ function checkEntityIdentities(entities, report) {
     }
 }
 /**
- * Properties, relationships, `<relationship>Id` fields and the inverses that land on an entity share
+ * Properties, relationships, `<relationship>_id` fields and the inverses that land on an entity share
  * one namespace: they are the record's fields and the API's traversal paths.
  */
 function checkMemberNames(entities, report) {
@@ -666,7 +707,7 @@ function ownMembers(candidate) {
         const path = `${candidate.name}.relationships.${name}`;
         const own = { name, path, inverse: false };
         return relationship.cardinality === "one" && candidate.entity.definition.source === undefined
-            ? [own, { ...own, name: `${name}Id` }]
+            ? [own, { ...own, name: `${name}_id` }]
             : [own];
     });
     return [...properties, ...relationships];

package/dist/authoring-input.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from "effect";
+/** A schema-aware codec: declared fields convert, JSON/dictionary keys and provider data do not. */
+export declare function actionInputToWire(input: Schema.Top): Schema.Top;

package/dist/authoring-input.js

@@ -0,0 +1,107 @@
+import { Schema, SchemaAST, SchemaTransformation } from "effect";
+import { propertyDefinition } from "./property.js";
+import { isRecord, nameToWire } from "./authoring-names.js";
+function mapChildren(ast, convert) {
+    switch (ast._tag) {
+        case "Objects":
+            return new SchemaAST.Objects(ast.propertySignatures.map((field) => new SchemaAST.PropertySignature(field.name, convert(field.type))), ast.indexSignatures.map((field) => new SchemaAST.IndexSignature(field.parameter, convert(field.type))), ast.annotations, ast.checks, ast.encoding, ast.context);
+        case "Arrays":
+            return new SchemaAST.Arrays(ast.isMutable, ast.elements.map(convert), ast.rest.map(convert), ast.annotations, ast.checks, ast.encoding, ast.context);
+        case "Union":
+            return new SchemaAST.Union(ast.types.map(convert), ast.options, ast.annotations, ast.checks, ast.encoding, ast.context);
+        case "Suspend":
+            return new SchemaAST.Suspend(() => convert(ast.thunk()), ast.annotations, undefined, ast.encoding, ast.context);
+        default:
+            return ast;
+    }
+}
+function selectToWire(ast) {
+    if (ast._tag === "Literal" && typeof ast.literal === "string") {
+        return new SchemaAST.Literal(nameToWire(ast.literal), ast.annotations, ast.checks, ast.encoding, ast.context);
+    }
+    return mapChildren(ast, selectToWire);
+}
+/** A schema-aware codec: declared fields convert, JSON/dictionary keys and provider data do not. */
+export function actionInputToWire(input) {
+    const encoded = Schema.toEncoded(input).ast;
+    const nodes = new WeakMap();
+    const wire = (ast) => {
+        const existing = nodes.get(ast);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const property = propertyDefinition(Schema.make(ast));
+        if (property?.type === "json") {
+            return ast;
+        }
+        if (property?.type === "select") {
+            return selectToWire(ast);
+        }
+        const nested = mapChildren(ast, wire);
+        if (nested._tag !== "Objects") {
+            nodes.set(ast, nested);
+            return nested;
+        }
+        const names = new Set();
+        const fields = nested.propertySignatures.map((field) => {
+            const name = typeof field.name === "string" ? nameToWire(field.name) : field.name;
+            if (names.has(name)) {
+                throw new Error(`Input fields collide on wire name ${String(name)}.`);
+            }
+            names.add(name);
+            return new SchemaAST.PropertySignature(name, field.type);
+        });
+        // Object checks run on the original camelCase shape after decoding below.
+        const result = new SchemaAST.Objects(fields, nested.indexSignatures, nested.annotations, undefined, undefined, nested.context);
+        nodes.set(ast, result);
+        return result;
+    };
+    const rename = (value, ast, decode) => {
+        const property = propertyDefinition(Schema.make(ast));
+        if (property?.type === "json") {
+            return value;
+        }
+        if (property?.type === "select" && typeof value === "string") {
+            return decode
+                ? (property.options?.find((option) => nameToWire(option.value) === value)?.value ?? value)
+                : nameToWire(value);
+        }
+        if (ast._tag === "Suspend") {
+            return rename(value, ast.thunk(), decode);
+        }
+        if (ast._tag === "Union") {
+            const member = ast.types.find((candidate) => Schema.is(Schema.make(decode ? wire(candidate) : candidate))(value));
+            return member === undefined ? value : rename(value, member, decode);
+        }
+        if (ast._tag === "Arrays" && Array.isArray(value)) {
+            return value.map((child, index) => {
+                const member = ast.elements[index] ?? ast.rest[0];
+                return member === undefined ? child : rename(child, member, decode);
+            });
+        }
+        if (ast._tag !== "Objects" || !isRecord(value)) {
+            return value;
+        }
+        return Object.fromEntries(Object.entries(value).map(([name, child]) => {
+            const field = ast.propertySignatures.find((candidate) => (decode && typeof candidate.name === "string"
+                ? nameToWire(candidate.name)
+                : candidate.name) === name);
+            return field === undefined
+                ? [
+                    name,
+                    ast.indexSignatures[0] === undefined
+                        ? child
+                        : rename(child, ast.indexSignatures[0].type, decode),
+                ]
+                : [
+                    decode ? field.name : nameToWire(String(field.name)),
+                    rename(child, field.type, decode),
+                ];
+        }));
+    };
+    const codec = Schema.make(wire(encoded)).pipe(Schema.decodeTo(input, SchemaTransformation.transform({
+        decode: (value) => rename(value, encoded, true),
+        encode: (value) => rename(value, encoded, false),
+    })));
+    return "fields" in input ? Object.assign(codec, { fields: input.fields }) : codec;
+}

package/dist/authoring-names.d.ts

@@ -0,0 +1,4 @@
+/** Leave malformed identifiers intact so validation still reports them. */
+export declare function nameToWire(name: string): string;
+export declare function permissionToWire(permission: string): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/dist/authoring-names.js

@@ -0,0 +1,13 @@
+import { toSnakeCase } from "./names.js";
+/** Leave malformed identifiers intact so validation still reports them. */
+export function nameToWire(name) {
+    return typeof name === "string" && /^[a-z][a-zA-Z0-9]*$/.test(name) ? toSnakeCase(name) : name;
+}
+export function permissionToWire(permission) {
+    return typeof permission === "string"
+        ? permission.split(":").map(nameToWire).join(":")
+        : permission;
+}
+export function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}

package/dist/authoring-records.d.ts

@@ -0,0 +1,16 @@
+import { type AnyEntity, type Properties, type Relationships } from "./entity.js";
+import type { Edit } from "./runtime/history.js";
+import type { FindOptions, StoredValues } from "./runtime.js";
+interface Definition {
+    readonly properties: Properties;
+    readonly relationships?: Relationships;
+}
+/** Only record keys and select identifiers convert; property values remain data. */
+export declare function recordFromWire<A>(value: unknown, definition?: Definition): A;
+export declare function valuesToWire(values: StoredValues, definition: Definition): StoredValues;
+export declare function findToWire(options: FindOptions, definition: Definition): FindOptions;
+/** Current action edits use the same property names and values as authored entity records. */
+export declare function editsFromWire(edits: ReadonlyArray<Edit>, entities: ReadonlyArray<AnyEntity>): ReadonlyArray<Edit>;
+/** Generated actions return entity records; authored action results remain application data. */
+export declare function generatedResultFromWire(value: unknown, action: string, definition?: Definition): unknown;
+export {};

package/dist/authoring-records.js

@@ -0,0 +1,144 @@
+import { isEntity } from "./entity.js";
+import { toCamelCase } from "./names.js";
+import { propertyDefinition } from "./property.js";
+import { isRecord, nameToWire } from "./authoring-names.js";
+function targetDefinition(target) {
+    const resolved = typeof target === "function" ? target() : target;
+    return isEntity(resolved) ? resolved.definition : undefined;
+}
+function selectValue(value, property, decode) {
+    const definition = propertyDefinition(property);
+    if (definition?.type !== "select") {
+        return value;
+    }
+    const convert = (child) => typeof child !== "string"
+        ? child
+        : decode
+            ? (definition.options?.find((option) => nameToWire(option.value) === child)?.value ?? child)
+            : nameToWire(child);
+    return Array.isArray(value) ? value.map(convert) : convert(value);
+}
+/** Only record keys and select identifiers convert; property values remain data. */
+export function recordFromWire(value, definition) {
+    if (!isRecord(value)) {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value).map(([name, child]) => {
+        const property = Object.entries(definition?.properties ?? {}).find(([key]) => nameToWire(key) === name);
+        if (property !== undefined) {
+            return [property[0], selectValue(child, property[1], true)];
+        }
+        const relationship = Object.entries(definition?.relationships ?? {}).find(([key]) => nameToWire(key) === name);
+        if (relationship !== undefined) {
+            const target = targetDefinition(relationship[1].target);
+            return [
+                relationship[0],
+                Array.isArray(child)
+                    ? child.map((item) => recordFromWire(item, target))
+                    : recordFromWire(child, target),
+            ];
+        }
+        return [toCamelCase(name), child];
+    }));
+}
+export function valuesToWire(values, definition) {
+    return Object.fromEntries(Object.entries(values).map(([name, value]) => [
+        nameToWire(name),
+        selectValue(value, definition.properties[name], false),
+    ]));
+}
+/** Translate query fields and relationships; operands of JSON filters stay opaque. */
+function whereToWire(where, definition) {
+    return Object.fromEntries(Object.entries(where).map(([name, condition]) => {
+        if ((name === "and" || name === "or") && Array.isArray(condition)) {
+            return [name, condition.map((child) => whereToWire(child, definition))];
+        }
+        if (name === "not" && isRecord(condition)) {
+            return [name, whereToWire(condition, definition)];
+        }
+        const property = definition?.properties[name];
+        const relationship = definition?.relationships?.[name];
+        if (relationship !== undefined && isRecord(condition)) {
+            const target = targetDefinition(relationship.target);
+            return [
+                nameToWire(name),
+                relationship.cardinality === "many"
+                    ? Object.fromEntries(Object.entries(condition).map(([quantifier, child]) => [
+                        quantifier,
+                        isRecord(child) ? whereToWire(child, target) : child,
+                    ]))
+                    : whereToWire(condition, target),
+            ];
+        }
+        if (isRecord(condition)) {
+            const operators = [
+                "eq",
+                "ne",
+                "in",
+                "isNull",
+                "contains",
+                "startsWith",
+                "gt",
+                "gte",
+                "lt",
+                "lte",
+                "between",
+            ];
+            if (Object.keys(condition).every((key) => operators.includes(key))) {
+                return [
+                    nameToWire(name),
+                    Object.fromEntries(Object.entries(condition).map(([key, child]) => [
+                        key,
+                        selectValue(child, property, false),
+                    ])),
+                ];
+            }
+            if (propertyDefinition(property)?.type !== "json") {
+                return [nameToWire(name), whereToWire(condition)];
+            }
+        }
+        return [nameToWire(name), selectValue(condition, property, false)];
+    }));
+}
+export function findToWire(options, definition) {
+    return {
+        ...options,
+        ...(options.where === undefined ? {} : { where: whereToWire(options.where, definition) }),
+        ...(options.orderBy === undefined
+            ? {}
+            : {
+                orderBy: options.orderBy.map((order) => ({ ...order, field: nameToWire(order.field) })),
+            }),
+        ...(options.include === undefined
+            ? {}
+            : {
+                include: Object.fromEntries(Object.entries(options.include).map(([name, value]) => [nameToWire(name), value])),
+            }),
+    };
+}
+/** Current action edits use the same property names and values as authored entity records. */
+export function editsFromWire(edits, entities) {
+    return edits.map((edit) => {
+        const definition = entities.find((entity) => nameToWire(entity.name) === edit.entity)?.definition;
+        const before = recordFromWire(Object.fromEntries(Object.entries(edit.changes).map(([field, change]) => [field, change.before])), definition);
+        const after = recordFromWire(Object.fromEntries(Object.entries(edit.changes).map(([field, change]) => [field, change.after])), definition);
+        return {
+            ...edit,
+            entity: toCamelCase(edit.entity),
+            changes: Object.fromEntries(Object.keys(before).map((field) => [
+                field,
+                { before: before[field], after: after[field] },
+            ])),
+        };
+    });
+}
+/** Generated actions return entity records; authored action results remain application data. */
+export function generatedResultFromWire(value, action, definition) {
+    if (action === "create" || action === "update") {
+        return recordFromWire(value, definition);
+    }
+    if (action.startsWith("upsert_by_") && isRecord(value)) {
+        return { ...value, record: recordFromWire(value.record, definition) };
+    }
+    return value;
+}

package/dist/authoring.d.ts

@@ -0,0 +1,12 @@
+import type { OntologyConfig } from "./analyze.js";
+import type { DiagnosticCode } from "./diagnostics.js";
+import { type AnyEntity } from "./entity.js";
+import type { Principal } from "./runtime.js";
+type Report = (code: DiagnosticCode, path: string, message: string) => void;
+export declare function principalFromWire(principal: Principal): Principal;
+/** Canonical definitions feed REST, storage and future transports; the public config stays camelCase. */
+export declare function authoringToWire(config: OntologyConfig, user: AnyEntity, report: Report): {
+    readonly config: OntologyConfig;
+    readonly user: AnyEntity;
+};
+export {};