@astrale-os/kernel-dsl 0.2.0-beta.35 → 0.2.0-beta.36

package/dist/v1/schema/compatibility/compare.d.ts

@@ -0,0 +1,57 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+import type { Definition, Key as SemanticKey, Revision } from '../../addressing/index.js';
+import type { DomainSchema } from '../model/schema.js';
+import type { MeaningDifference } from './diff.js';
+import type { DependencyMeaningLevel } from './fields.js';
+import type { MeaningFingerprint } from './meaning.js';
+export type DependencyMeaningChangeKind = 'missing' | 'changed' | 'added';
+export type DependencyMeaningChange = {
+    readonly key: SemanticKey;
+    readonly kind: 'missing';
+    readonly sourceFingerprint: MeaningFingerprint;
+} | {
+    readonly key: SemanticKey;
+    readonly kind: 'changed';
+    readonly sourceFingerprint: MeaningFingerprint;
+    readonly targetFingerprint: MeaningFingerprint;
+    /** Every exact path of the meaning that differs, in JSON Pointer order. */
+    readonly differences: readonly MeaningDifference[];
+} | {
+    /** A required, non-automatic Property the target adds to an inherited Class. */
+    readonly key: SemanticKey;
+    readonly kind: 'added';
+    readonly targetFingerprint: MeaningFingerprint;
+    readonly meaning: JsonValue;
+};
+export interface DependencyMeaningComparison {
+    readonly version: 3;
+    readonly dependency: SemanticKey.Origin;
+    readonly source: Revision;
+    readonly target: Revision;
+    readonly footprint: readonly SemanticKey[];
+    readonly changes: readonly DependencyMeaningChange[];
+    readonly fingerprint: MeaningFingerprint;
+}
+/** One footprint entry: the Key, what it is, and for a Class how strongly it is used. */
+export interface FootprintEntry {
+    readonly key: SemanticKey;
+    readonly kind: Definition.Kind | 'property' | 'method';
+    readonly level?: DependencyMeaningLevel;
+}
+/**
+ * Compare the exact V1 meaning one accepted Domain used from a retained dependency with a
+ * candidate revision of that same dependency origin. This operation is pure and makes no
+ * lifecycle-compatibility decision.
+ */
+export declare function compareDependencyMeaning(dependent: DomainSchema, target: DomainSchema): DependencyMeaningComparison;
+/** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
+export declare function compareMemberMeaning(source: DomainSchema, target: DomainSchema, roots: readonly [SemanticKey, ...SemanticKey[]]): DependencyMeaningComparison;
+/** The footprint one accepted Domain takes from a retained dependency, Key-ordered. */
+export declare function footprintOf(dependent: DomainSchema, origin: SemanticKey.Origin): readonly FootprintEntry[];
+/**
+ * The meaning one Domain gives one of its own Keys at a usage level; a Key the Domain does not
+ * declare is rejected with DM_MEMBER_ROOT_INVALID.
+ */
+export declare function meaningOf(schema: DomainSchema, key: SemanticKey, level?: DependencyMeaningLevel): JsonValue;
+/** One line an operator can act on, naming the exact paths of a changed meaning. */
+export declare function describeMeaningChange(change: DependencyMeaningChange): string;

package/dist/v1/schema/compatibility/compare.js

@@ -0,0 +1,166 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+import { revisionOfDomainSchema } from '../canonical/revision.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { knownDomainClosure } from '../resolution/closure.js';
+import { resolve } from '../resolution/domain.js';
+import { contextOf, effectiveDefinition } from './context.js';
+import { differences } from './diff.js';
+import { collectReachableMeanings, collectSchemaRoots, coordinateForKey } from './footprint.js';
+import { fingerprintMeaning, meaningForCoordinate, propertyMeaning } from './meaning.js';
+/**
+ * Compare the exact V1 meaning one accepted Domain used from a retained dependency with a
+ * candidate revision of that same dependency origin. This operation is pure and makes no
+ * lifecycle-compatibility decision.
+ */
+export function compareDependencyMeaning(dependent, target) {
+    const { source, meanings } = retainedMeanings(dependent, target.origin, '/target/origin');
+    return compareSourceMeanings(source, target, meanings);
+}
+/** Compare one explicit non-empty source member surface and its reachable V1 meaning. */
+export function compareMemberMeaning(source, target, roots) {
+    if (source.origin !== target.origin) {
+        throw new SchemaError([
+            diagnostic('DM_MEMBER_ORIGIN_MISMATCH', '/target/origin', `Member comparison target ${target.origin} does not match source ${source.origin}.`),
+        ]);
+    }
+    if (!Array.isArray(roots) || roots.length === 0 || new Set(roots).size !== roots.length) {
+        throw new SchemaError([
+            diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', 'Member comparison roots must be one non-empty duplicate-free Key set.'),
+        ]);
+    }
+    resolve(source);
+    const context = contextOf(source);
+    const coordinates = roots.map((key, index) => coordinateForKey(context, source, key, index));
+    const meanings = collectReachableMeanings(coordinates, source.origin, context);
+    return compareSourceMeanings(source, target, meanings);
+}
+/** The footprint one accepted Domain takes from a retained dependency, Key-ordered. */
+export function footprintOf(dependent, origin) {
+    const { meanings } = retainedMeanings(dependent, origin, '/origin');
+    return Object.freeze([...meanings.values()]
+        .map(({ coordinate }) => Object.freeze({
+        key: coordinate.key,
+        kind: coordinate.kind === 'member' ? coordinate.ref.kind : coordinate.kind,
+        ...(coordinate.kind === 'class' ? { level: coordinate.level } : {}),
+    }))
+        .sort((left, right) => compareUnicode(left.key, right.key)));
+}
+/**
+ * The meaning one Domain gives one of its own Keys at a usage level; a Key the Domain does not
+ * declare is rejected with DM_MEMBER_ROOT_INVALID.
+ */
+export function meaningOf(schema, key, level = 'reference') {
+    resolve(schema);
+    const context = contextOf(schema);
+    const coordinate = coordinateForKey(context, schema, key, 0, level);
+    return meaningForCoordinate(context, coordinate);
+}
+/** One line an operator can act on, naming the exact paths of a changed meaning. */
+export function describeMeaningChange(change) {
+    switch (change.kind) {
+        case 'missing':
+            return `${change.key} missing`;
+        case 'added':
+            return `${change.key} added as an obligation`;
+        case 'changed': {
+            const paths = change.differences.map(({ path }) => path);
+            const shown = paths.slice(0, 3).join(', ');
+            return `${change.key} changed at ${paths.length > 3 ? `${shown} and ${paths.length - 3} more` : shown}`;
+        }
+    }
+}
+/** The retained dependency at one origin and every meaning the dependent reaches in it. */
+function retainedMeanings(dependent, origin, path) {
+    resolve(dependent);
+    const context = contextOf(dependent);
+    const source = (knownDomainClosure(dependent) ?? []).find((candidate) => candidate.schema.origin === origin)?.schema;
+    if (source === undefined) {
+        throw new SchemaError([
+            diagnostic('DM_DEPENDENCY_NOT_RETAINED', path, `Domain ${dependent.origin} was not admitted with a dependency at ${origin}.`),
+        ]);
+    }
+    return {
+        source,
+        meanings: collectReachableMeanings(collectSchemaRoots(dependent), source.origin, context),
+    };
+}
+/**
+ * A footprint coordinate is unchanged only when the same Key exists in the target with the same
+ * meaning projected onto the source requirement of its usage level. Additions outside the
+ * footprint are free; a required non-automatic Property the target adds to an inherited Class is
+ * the one addition reported, as an obligation.
+ */
+function compareSourceMeanings(source, target, sourceMeanings) {
+    // Prove the candidate still has an exact accepted semantic context before comparing it.
+    resolve(target);
+    const context = contextOf(target);
+    const footprint = Object.freeze([...sourceMeanings.keys()].sort(compareUnicode));
+    const changes = [];
+    const comparisonCoordinates = [];
+    for (const key of footprint) {
+        const sourceMeaning = sourceMeanings.get(key);
+        const targetMeaning = meaningForCoordinate(context, sourceMeaning.coordinate, sourceMeaning.requirement);
+        const targetFingerprint = targetMeaning === undefined ? undefined : fingerprintMeaning(targetMeaning);
+        comparisonCoordinates.push([
+            key,
+            sourceMeaning.fingerprint,
+            targetFingerprint ?? null,
+        ]);
+        if (targetMeaning === undefined || targetFingerprint === undefined) {
+            changes.push(Object.freeze({ key, kind: 'missing', sourceFingerprint: sourceMeaning.fingerprint }));
+        }
+        else if (targetFingerprint !== sourceMeaning.fingerprint) {
+            changes.push(Object.freeze({
+                key,
+                kind: 'changed',
+                sourceFingerprint: sourceMeaning.fingerprint,
+                targetFingerprint,
+                differences: differences(sourceMeaning.meaning, targetMeaning),
+            }));
+        }
+    }
+    const additions = addedObligations(context, sourceMeanings);
+    const sourceRevision = revisionOfDomainSchema(source);
+    const targetRevision = revisionOfDomainSchema(target);
+    const fingerprint = fingerprintMeaning({
+        version: 3,
+        dependency: source.origin,
+        source: sourceRevision,
+        target: targetRevision,
+        coordinates: comparisonCoordinates,
+        additions: additions.map(({ key, targetFingerprint }) => [key, targetFingerprint]),
+    });
+    return Object.freeze({
+        version: 3,
+        dependency: source.origin,
+        source: sourceRevision,
+        target: targetRevision,
+        footprint,
+        changes: Object.freeze([...changes, ...additions]),
+        fingerprint,
+    });
+}
+/** A target may extend an inherited Class only with optional or automatic Properties. */
+function addedObligations(context, sourceMeanings) {
+    const additions = new Map();
+    for (const { coordinate, requirement } of sourceMeanings.values()) {
+        if (coordinate.kind !== 'class' || coordinate.level !== 'inherit' || requirement === undefined)
+            continue;
+        const owner = context.schemas.get(coordinate.ref.origin);
+        const analysis = owner === undefined ? undefined : effectiveDefinition(context, owner, coordinate.ref);
+        if (analysis === undefined)
+            continue;
+        for (const field of analysis.properties.values()) {
+            if (requirement.properties.has(field.identity) || !field.required || field.auto !== undefined)
+                continue;
+            const meaning = propertyMeaning(field);
+            additions.set(field.identity, Object.freeze({
+                key: field.identity,
+                kind: 'added',
+                targetFingerprint: fingerprintMeaning(meaning),
+                meaning,
+            }));
+        }
+    }
+    return [...additions.values()].sort((left, right) => compareUnicode(left.key, right.key));
+}

package/dist/v1/schema/compatibility/context.d.ts

@@ -0,0 +1,15 @@
+import type { ClassRef, DefinitionRef, Key as SemanticKey } from '../../addressing/index.js';
+import type { DefinitionAnalysis, EffectiveMethod } from '../analysis/class.js';
+import type { DomainSchema } from '../model/schema.js';
+import { SchemaError } from '../diagnostic.js';
+/** One accepted root with its exact closure and a memoized semantic analysis per owner. */
+export interface Context {
+    readonly schemas: ReadonlyMap<string, DomainSchema>;
+    analysis(owner: DomainSchema): ReadonlyMap<string, DefinitionAnalysis> | undefined;
+}
+export declare function contextOf(root: DomainSchema): Context;
+export declare function effectiveDefinition(context: Context, owner: DomainSchema, ref: ClassRef): DefinitionAnalysis | undefined;
+/** Effective Methods are keyed by name; a coordinate names one by its exact Method Key. */
+export declare function effectiveMethod(analysis: DefinitionAnalysis, key: SemanticKey): EffectiveMethod | undefined;
+export declare function requireOwner(context: Context, ref: DefinitionRef, key: SemanticKey): DomainSchema;
+export declare function contextInvalid(message: string, key: SemanticKey): SchemaError;

package/dist/v1/schema/compatibility/context.js

@@ -0,0 +1,43 @@
+import { MethodKey } from '../../addressing/index.js';
+import { definitionRefIndex } from '../../addressing/ordering.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+import { knownDomainClosure, lookupForDomainClosure } from '../resolution/closure.js';
+import { validateDomainSchemaSemantics } from '../validation/domain.js';
+export function contextOf(root) {
+    const schemas = new Map([
+        [root.origin, root],
+        ...(knownDomainClosure(root) ?? []).map(({ schema }) => [schema.origin, schema]),
+    ]);
+    const analyses = new Map();
+    return {
+        schemas,
+        analysis(owner) {
+            if (!analyses.has(owner)) {
+                const validation = validateDomainSchemaSemantics(owner, lookupForDomainClosure(owner));
+                analyses.set(owner, validation.diagnostics.length > 0 ? undefined : validation.analysis.definitions);
+            }
+            return analyses.get(owner);
+        },
+    };
+}
+export function effectiveDefinition(context, owner, ref) {
+    return context.analysis(owner)?.get(definitionRefIndex(ref));
+}
+/** Effective Methods are keyed by name; a coordinate names one by its exact Method Key. */
+export function effectiveMethod(analysis, key) {
+    for (const method of analysis.methods.values()) {
+        if (MethodKey.of(method.owner, method.name) === key)
+            return method;
+    }
+    return undefined;
+}
+export function requireOwner(context, ref, key) {
+    const owner = context.schemas.get(ref.origin);
+    if (owner === undefined) {
+        throw contextInvalid(`Retained acceptance context cannot resolve ${key}.`, key);
+    }
+    return owner;
+}
+export function contextInvalid(message, key) {
+    return new SchemaError([diagnostic('DM_DEPENDENCY_CONTEXT_INVALID', '', message, key)]);
+}

package/dist/v1/schema/compatibility/coordinate.d.ts

@@ -0,0 +1,44 @@
+import type { ClassRef, Definition, DefinitionRef, Key as SemanticKey, PropertyKey as SemanticPropertyKey } from '../../addressing/index.js';
+import type { ReferenceSite } from '../resolution/origins.js';
+import type { DependencyMeaningLevel } from './fields.js';
+export type MemberRef = DefinitionRef<Exclude<Definition.Kind, 'class'>>;
+export type ClassCoordinate = Readonly<{
+    kind: 'class';
+    key: SemanticKey;
+    ref: ClassRef;
+    level: DependencyMeaningLevel;
+}>;
+export type MemberCoordinate = Readonly<{
+    kind: 'member';
+    key: SemanticKey;
+    ref: MemberRef;
+}>;
+export type PropertyCoordinate = Readonly<{
+    kind: 'property';
+    key: SemanticPropertyKey;
+    owner: ClassRef;
+    name: string;
+}>;
+export type MethodCoordinate = Readonly<{
+    kind: 'method';
+    key: SemanticKey;
+    owner: ClassRef;
+    name: string;
+}>;
+/** One exact semantic location of a dependency, as the dependent reaches it. */
+export type Coordinate = ClassCoordinate | MemberCoordinate | PropertyCoordinate | MethodCoordinate;
+/** `extends` and Core instantiation take on the creation contract; every other site only refers. */
+export declare function levelOf(site: ReferenceSite | undefined): DependencyMeaningLevel;
+export declare function classCoordinate(ref: ClassRef, level: DependencyMeaningLevel): ClassCoordinate;
+export declare function memberCoordinate(ref: MemberRef): MemberCoordinate;
+export declare function propertyCoordinate(owner: ClassRef, name: string): PropertyCoordinate;
+export declare function methodCoordinate(owner: ClassRef, name: string): MethodCoordinate;
+export declare function keyForDefinitionRef(ref: DefinitionRef): SemanticKey;
+export interface ParsedKeyReference {
+    readonly kind: Definition.Kind;
+    readonly name: string;
+    readonly member?: 'property' | 'method';
+    readonly ownerName?: string;
+}
+/** Interpret one canonical V1 Key as a Definition or a Class member location. */
+export declare function keyReference(key: SemanticKey): ParsedKeyReference;

package/dist/v1/schema/compatibility/coordinate.js

@@ -0,0 +1,42 @@
+import { Key, MethodKey, PropertyKey } from '../../addressing/index.js';
+import { SchemaError, diagnostic } from '../diagnostic.js';
+/** `extends` and Core instantiation take on the creation contract; every other site only refers. */
+export function levelOf(site) {
+    return site === 'extends' || site === 'core' ? 'inherit' : 'reference';
+}
+export function classCoordinate(ref, level) {
+    return Object.freeze({ kind: 'class', key: keyForDefinitionRef(ref), ref, level });
+}
+export function memberCoordinate(ref) {
+    return Object.freeze({ kind: 'member', key: keyForDefinitionRef(ref), ref });
+}
+export function propertyCoordinate(owner, name) {
+    return Object.freeze({ kind: 'property', key: PropertyKey.of(owner, name), owner, name });
+}
+export function methodCoordinate(owner, name) {
+    return Object.freeze({ kind: 'method', key: MethodKey.of(owner, name), owner, name });
+}
+export function keyForDefinitionRef(ref) {
+    return ref.kind === 'core'
+        ? Key.of(ref)
+        : Key.of(ref);
+}
+/** Interpret one canonical V1 Key as a Definition or a Class member location. */
+export function keyReference(key) {
+    const semantic = key.slice(key.indexOf(':') + 1);
+    const parts = semantic.split('.');
+    if (parts[0] === 'core' && parts.length === 2) {
+        return { kind: 'core', name: parts[1] };
+    }
+    if (parts.length === 2) {
+        return { kind: parts[0], name: parts[1] };
+    }
+    if (parts.length === 4 &&
+        parts[0] === 'class' &&
+        (parts[2] === 'property' || parts[2] === 'method')) {
+        return { kind: 'class', name: parts[3], member: parts[2], ownerName: parts[1] };
+    }
+    throw new SchemaError([
+        diagnostic('DM_MEMBER_ROOT_INVALID', '/roots', `Key ${key} has no supported V1 shape.`, key),
+    ]);
+}

package/dist/v1/schema/compatibility/diff.d.ts

@@ -0,0 +1,12 @@
+import type { Value as JsonValue } from '@astrale-os/kernel-dsl/value';
+/**
+ * One exact place where two meanings differ, addressed by JSON Pointer into the meaning value.
+ * An absent side is omitted: `before` only means removed, `after` only means added.
+ */
+export interface MeaningDifference {
+    readonly path: string;
+    readonly before?: JsonValue;
+    readonly after?: JsonValue;
+}
+/** Structural differences between two portable values, leaf by leaf, in JSON Pointer order. */
+export declare function differences(before: JsonValue, after: JsonValue): readonly MeaningDifference[];

package/dist/v1/schema/compatibility/diff.js

@@ -0,0 +1,39 @@
+import { compareUnicode } from '../../addressing/ordering.js';
+import { isValueObject as isJsonObject } from '../../language/value/model/object.js';
+/** Structural differences between two portable values, leaf by leaf, in JSON Pointer order. */
+export function differences(before, after) {
+    const found = [];
+    collect(before, after, '', found);
+    return Object.freeze(found.sort((left, right) => compareUnicode(left.path, right.path)));
+}
+function collect(before, after, path, found) {
+    if (Array.isArray(before) && Array.isArray(after)) {
+        const length = Math.max(before.length, after.length);
+        for (let index = 0; index < length; index += 1) {
+            collect(before[index], after[index], `${path}/${index}`, found);
+        }
+        return;
+    }
+    if (isJsonObject(before) && isJsonObject(after)) {
+        const keys = [...new Set([...Object.keys(before), ...Object.keys(after)])].sort(compareUnicode);
+        for (const key of keys) {
+            collect(before[key], after[key], `${path}/${escape(key)}`, found);
+        }
+        return;
+    }
+    if (before === undefined && after === undefined)
+        return;
+    if (before !== undefined &&
+        after !== undefined &&
+        JSON.stringify(before) === JSON.stringify(after)) {
+        return;
+    }
+    found.push(Object.freeze({
+        path,
+        ...(before === undefined ? {} : { before }),
+        ...(after === undefined ? {} : { after }),
+    }));
+}
+function escape(segment) {
+    return segment.replaceAll('~', '~0').replaceAll('/', '~1');
+}

package/dist/v1/schema/compatibility/fields.d.ts

@@ -0,0 +1,180 @@
+/**
+ * How strongly a dependent relies on a dependency Class. `inherit` covers `extends` and Core
+ * instantiation, which take on the Class creation contract; `reference` covers every other site,
+ * which only names the Class and reads its surface.
+ */
+export type DependencyMeaningLevel = 'reference' | 'inherit';
+/**
+ * Where one declaration field counts for a dependent:
+ * - `always`: at every usage level;
+ * - `inherit`: only when the dependent inherits or instantiates the Class;
+ * - `members`: as separate Property and Method coordinates with their own meaning;
+ * - `excluded`: never, for the stated reason.
+ *
+ * Every field of every declaration kind is classified below. A field added to the DSL does not
+ * compile until it is classified, so meaning can only be narrowed by an explicit decision.
+ */
+export type FieldRole = 'always' | 'inherit' | 'members' | {
+    readonly excluded: 'identity' | 'annotation' | 'authorization' | 'presentation';
+};
+/** The coordinate Key already names the declaration; its `ref` is never repeated in the meaning. */
+export declare const CLASS_FIELDS: Readonly<{
+    ref: Readonly<{
+        excluded: 'identity';
+    }>;
+    kind: "always";
+    abstract: "always";
+    orientation: "always";
+    extends: "inherit";
+    policies: "inherit";
+    data: "inherit";
+    endpoints: "inherit";
+    constraints: "inherit";
+    properties: "members";
+    methods: "members";
+    description: Readonly<{
+        excluded: 'annotation';
+    }>;
+    icon: Readonly<{
+        excluded: 'presentation';
+    }>;
+}>;
+export declare const PROPERTY_FIELDS: Readonly<{
+    schema: "always";
+    required: "always";
+    auto: "always";
+    state: "always";
+    description: Readonly<{
+        excluded: 'annotation';
+    }>;
+}>;
+/** The auth level and Policy check are decided by the Runtime at invocation, never compiled against. */
+export declare const CALLABLE_FIELDS: Readonly<{
+    ref: Readonly<{
+        excluded: 'identity';
+    }>;
+    input: "always";
+    output: "always";
+    static: "always";
+    abstract: "always";
+    auth: Readonly<{
+        excluded: 'authorization';
+    }>;
+    policy: Readonly<{
+        excluded: 'authorization';
+    }>;
+    description: Readonly<{
+        excluded: 'annotation';
+    }>;
+}>;
+export declare const POLICY_FIELDS: Readonly<{
+    ref: Readonly<{
+        excluded: 'identity';
+    }>;
+    expression: "always";
+    description: Readonly<{
+        excluded: 'annotation';
+    }>;
+}>;
+export declare const VIEW_FIELDS: Readonly<{
+    ref: Readonly<{
+        excluded: 'identity';
+    }>;
+    target: "always";
+    description: Readonly<{
+        excluded: 'annotation';
+    }>;
+}>;
+export declare const CORE_FIELDS: Readonly<{
+    ref: Readonly<{
+        excluded: 'identity';
+    }>;
+    class: "always";
+    properties: "always";
+    source: "always";
+    target: "always";
+}>;
+/**
+ * JSON Schema keywords that annotate a value schema without constraining its values. Every other
+ * keyword, `x-astrale-path` included, is semantic; arbitrary JSON data is never inspected as schema.
+ * A frozen, Unicode-ordered list like the role tables: printable, and immutable at runtime.
+ */
+export declare const ANNOTATION_KEYWORDS: readonly string[];
+/** The complete classification, one table per declaration kind. */
+export declare const FIELD_ROLES: Readonly<{
+    class: Readonly<{
+        ref: Readonly<{
+            excluded: 'identity';
+        }>;
+        kind: "always";
+        abstract: "always";
+        orientation: "always";
+        extends: "inherit";
+        policies: "inherit";
+        data: "inherit";
+        endpoints: "inherit";
+        constraints: "inherit";
+        properties: "members";
+        methods: "members";
+        description: Readonly<{
+            excluded: 'annotation';
+        }>;
+        icon: Readonly<{
+            excluded: 'presentation';
+        }>;
+    }>;
+    property: Readonly<{
+        schema: "always";
+        required: "always";
+        auto: "always";
+        state: "always";
+        description: Readonly<{
+            excluded: 'annotation';
+        }>;
+    }>;
+    callable: Readonly<{
+        ref: Readonly<{
+            excluded: 'identity';
+        }>;
+        input: "always";
+        output: "always";
+        static: "always";
+        abstract: "always";
+        auth: Readonly<{
+            excluded: 'authorization';
+        }>;
+        policy: Readonly<{
+            excluded: 'authorization';
+        }>;
+        description: Readonly<{
+            excluded: 'annotation';
+        }>;
+    }>;
+    policy: Readonly<{
+        ref: Readonly<{
+            excluded: 'identity';
+        }>;
+        expression: "always";
+        description: Readonly<{
+            excluded: 'annotation';
+        }>;
+    }>;
+    view: Readonly<{
+        ref: Readonly<{
+            excluded: 'identity';
+        }>;
+        target: "always";
+        description: Readonly<{
+            excluded: 'annotation';
+        }>;
+    }>;
+    core: Readonly<{
+        ref: Readonly<{
+            excluded: 'identity';
+        }>;
+        class: "always";
+        properties: "always";
+        source: "always";
+        target: "always";
+    }>;
+}>;