@getaster/data 0.0.0-stage → 0.1.0-preview.0

package/dist/schema/csdl.js

@@ -0,0 +1,531 @@
+/** A metadata problem, with the JSON path of the offending member. */
+export class SchemaError extends Error {
+    path;
+    constructor(message, path) {
+        super(`${path}: ${message}`);
+        this.name = "SchemaError";
+        this.path = path;
+    }
+}
+const EDM_TYPES = new Set([
+    "Edm.String",
+    "Edm.Boolean",
+    "Edm.Byte",
+    "Edm.SByte",
+    "Edm.Int16",
+    "Edm.Int32",
+    "Edm.Int64",
+    "Edm.Single",
+    "Edm.Double",
+    "Edm.Decimal",
+    "Edm.Date",
+    "Edm.TimeOfDay",
+    "Edm.DateTimeOffset",
+    "Edm.Duration",
+    "Edm.Guid",
+    "Edm.Binary",
+]);
+class FrozenMap extends Map {
+    #sealed = false;
+    seal() {
+        this.#sealed = true;
+        return this;
+    }
+    set(key, value) {
+        if (this.#sealed)
+            throw new TypeError("schema is immutable");
+        return super.set(key, value);
+    }
+    delete(_key) {
+        throw new TypeError("schema is immutable");
+    }
+    clear() {
+        throw new TypeError("schema is immutable");
+    }
+}
+class FrozenSet extends Set {
+    #sealed = false;
+    seal() {
+        this.#sealed = true;
+        return this;
+    }
+    add(value) {
+        if (this.#sealed)
+            throw new TypeError("schema is immutable");
+        return super.add(value);
+    }
+    delete(_value) {
+        throw new TypeError("schema is immutable");
+    }
+    clear() {
+        throw new TypeError("schema is immutable");
+    }
+}
+function frozenSet(items) {
+    const s = new FrozenSet();
+    for (const i of items)
+        s.add(i);
+    return s.seal();
+}
+function isObject(v) {
+    return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function obj(v, path) {
+    if (!isObject(v))
+        throw new SchemaError("expected an object", path);
+    return v;
+}
+function optBool(o, key, path) {
+    const v = o[key];
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== "boolean")
+        throw new SchemaError("expected a boolean", `${path}/${key}`);
+    return v;
+}
+function optInt(o, key, path) {
+    const v = o[key];
+    if (v === undefined)
+        return undefined;
+    if (typeof v !== "number" || !Number.isInteger(v) || v < 0) {
+        throw new SchemaError("expected a non-negative integer", `${path}/${key}`);
+    }
+    return v;
+}
+/** Maps a vocabulary namespace or alias to the alias it is known by here. */
+function namespaceResolver(root) {
+    const map = new Map();
+    const refs = root["$Reference"];
+    if (refs !== undefined) {
+        for (const [uri, ref] of Object.entries(obj(refs, "/$Reference"))) {
+            const includes = obj(ref, `/$Reference/${uri}`)["$Include"];
+            if (includes === undefined)
+                continue;
+            if (!Array.isArray(includes)) {
+                throw new SchemaError("expected an array", `/$Reference/${uri}/$Include`);
+            }
+            includes.forEach((inc, i) => {
+                const p = `/$Reference/${uri}/$Include/${i}`;
+                const o = obj(inc, p);
+                const ns = o["$Namespace"];
+                if (typeof ns !== "string")
+                    throw new SchemaError("expected a string", `${p}/$Namespace`);
+                const alias = typeof o["$Alias"] === "string" ? o["$Alias"] : ns;
+                map.set(ns, alias);
+                map.set(alias, alias);
+            });
+        }
+    }
+    return (ns) => map.get(ns) ?? ns;
+}
+/** `@Org.OData.Core.V1.Description#q` becomes `Core.Description#q`; `@A@B` chains. */
+function annotationKey(raw, resolve) {
+    return raw
+        .split("@")
+        .filter((s) => s !== "")
+        .map((seg) => {
+        const hash = seg.indexOf("#");
+        const term = hash < 0 ? seg : seg.slice(0, hash);
+        const qualifier = hash < 0 ? "" : seg.slice(hash);
+        const dot = term.lastIndexOf(".");
+        if (dot < 0)
+            return seg;
+        return `${resolve(term.slice(0, dot))}${term.slice(dot)}${qualifier}`;
+    })
+        .join("@");
+}
+function annotationsOf(o, resolve) {
+    const out = {};
+    for (const [k, v] of Object.entries(o)) {
+        if (k.startsWith("@"))
+            out[annotationKey(k, resolve)] = v;
+    }
+    return out;
+}
+function str(v) {
+    return typeof v === "string" ? v : undefined;
+}
+function num(v) {
+    return typeof v === "number" ? v : undefined;
+}
+function toValue(v, path) {
+    if (v === null || typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+        return v;
+    }
+    throw new SchemaError("expected a primitive value", path);
+}
+function propertyPaths(v) {
+    if (!Array.isArray(v))
+        return [];
+    const out = [];
+    for (const item of v) {
+        if (typeof item === "string")
+            out.push(item);
+        else if (isObject(item) && typeof item["$PropertyPath"] === "string") {
+            out.push(item["$PropertyPath"]);
+        }
+    }
+    return out;
+}
+/**
+ * Parses a CSDL JSON 4.01 `$metadata` document. Throws `SchemaError` when
+ * the document is malformed; a property it can't model (a stream, an
+ * untyped or complex value, a collection) is left out and listed in
+ * `skipped`, and the rest of the schema stands.
+ */
+export function parseCsdl(json) {
+    const root = obj(json, "");
+    const resolve = namespaceResolver(root);
+    const skipped = [];
+    const namespaces = Object.keys(root).filter((k) => !k.startsWith("$") && !k.startsWith("@"));
+    if (namespaces.length === 0)
+        throw new SchemaError("no schema namespace", "");
+    /** Alias or namespace to namespace. */
+    const byAlias = new Map();
+    for (const ns of namespaces) {
+        byAlias.set(ns, ns);
+        const alias = str(obj(root[ns], `/${ns}`)["$Alias"]);
+        if (alias !== undefined)
+            byAlias.set(alias, ns);
+    }
+    const qualify = (name, path) => {
+        const dot = name.lastIndexOf(".");
+        const ns = dot < 0 ? undefined : byAlias.get(name.slice(0, dot));
+        if (ns === undefined)
+            throw new SchemaError(`type '${name}' is not in this document`, path);
+        return `${ns}.${name.slice(dot + 1)}`;
+    };
+    const containerRef = root["$EntityContainer"];
+    if (typeof containerRef !== "string") {
+        throw new SchemaError("missing $EntityContainer", "/$EntityContainer");
+    }
+    const containerQualified = qualify(containerRef, "/$EntityContainer");
+    const namespace = containerQualified.slice(0, containerQualified.lastIndexOf("."));
+    const containerName = containerQualified.slice(namespace.length + 1);
+    const typeDrafts = new Map();
+    let containerJson;
+    for (const ns of namespaces) {
+        for (const [name, member] of Object.entries(obj(root[ns], `/${ns}`))) {
+            if (name.startsWith("$") || name.startsWith("@"))
+                continue;
+            const p = `/${ns}/${name}`;
+            const o = obj(member, p);
+            if (o["$Kind"] === "EntityType")
+                typeDrafts.set(`${ns}.${name}`, { qualified: `${ns}.${name}`, name, namespace: ns, path: p, json: o });
+            else if (o["$Kind"] === "EntityContainer" && ns === namespace && name === containerName)
+                containerJson = o;
+        }
+    }
+    if (!containerJson) {
+        throw new SchemaError(`entity container '${containerRef}' not found`, "/$EntityContainer");
+    }
+    /** A type's own members, then its base type's: a derived type has every property its base has. */
+    const chain = (draft) => {
+        const out = [];
+        for (let d = draft; d;) {
+            if (out.includes(d))
+                throw new SchemaError("$BaseType cycle", `${draft.path}/$BaseType`);
+            out.push(d);
+            const base = d.json["$BaseType"];
+            if (base === undefined)
+                break;
+            if (typeof base !== "string")
+                throw new SchemaError("expected a string", `${d.path}/$BaseType`);
+            const next = typeDrafts.get(qualify(base, `${d.path}/$BaseType`));
+            if (!next)
+                throw new SchemaError(`unknown base type '${base}'`, `${d.path}/$BaseType`);
+            d = next;
+        }
+        return out;
+    };
+    const fieldsByType = new Map();
+    const keysByType = new Map();
+    const navsDraftByType = new Map();
+    const typeAnnotations = new Map();
+    for (const [qualified, draft] of typeDrafts) {
+        const fields = [];
+        const navs = [];
+        let rawKey;
+        let keyPath = "";
+        const annotations = {};
+        for (const d of chain(draft).reverse()) {
+            Object.assign(annotations, annotationsOf(d.json, resolve));
+            if (d.json["$Key"] !== undefined)
+                [rawKey, keyPath] = [d.json["$Key"], `${d.path}/$Key`];
+            for (const [name, member] of Object.entries(d.json)) {
+                if (name.startsWith("$") || name.startsWith("@"))
+                    continue;
+                const p = `${d.path}/${name}`;
+                const o = obj(member, p);
+                if (o["$Kind"] === "NavigationProperty") {
+                    const t = o["$Type"];
+                    if (typeof t !== "string")
+                        throw new SchemaError("missing $Type", `${p}/$Type`);
+                    navs.push({ typeName: qualified, name, path: p, raw: o, targetType: qualify(t, `${p}/$Type`) });
+                    continue;
+                }
+                const reason = unmodelled(o);
+                if (reason)
+                    skipped.push({ path: p, reason });
+                else
+                    fields.push(parseField(name, o, p, resolve));
+            }
+        }
+        let key = [];
+        if (rawKey !== undefined) {
+            if (!Array.isArray(rawKey))
+                throw new SchemaError("expected an array", keyPath);
+            key = rawKey.map((k, i) => {
+                if (typeof k !== "string") {
+                    throw new SchemaError("only simple key property names are supported", `${keyPath}/${i}`);
+                }
+                if (!fields.some((f) => f.name === k)) {
+                    throw new SchemaError(`key property '${k}' is not a property`, `${keyPath}/${i}`);
+                }
+                return k;
+            });
+        }
+        fieldsByType.set(qualified, fields);
+        keysByType.set(qualified, key);
+        navsDraftByType.set(qualified, navs);
+        typeAnnotations.set(qualified, annotations);
+    }
+    const setDrafts = [];
+    for (const [name, member] of Object.entries(containerJson)) {
+        if (name.startsWith("$") || name.startsWith("@"))
+            continue;
+        const p = `/${namespace}/${containerName}/${name}`;
+        const o = obj(member, p);
+        if (o["$Collection"] !== true || typeof o["$Type"] !== "string")
+            continue;
+        const typeName = qualify(o["$Type"], `${p}/$Type`);
+        if (!typeDrafts.has(typeName)) {
+            throw new SchemaError(`unknown entity type '${o["$Type"]}'`, `${p}/$Type`);
+        }
+        const bindings = new Map();
+        const b = o["$NavigationPropertyBinding"];
+        if (b !== undefined) {
+            for (const [navPath, target] of Object.entries(obj(b, `${p}/$NavigationPropertyBinding`))) {
+                if (typeof target !== "string") {
+                    throw new SchemaError("expected a string", `${p}/$NavigationPropertyBinding/${navPath}`);
+                }
+                bindings.set(navPath, target);
+            }
+        }
+        setDrafts.push({
+            name,
+            typeName,
+            path: p,
+            raw: o,
+            bindings,
+            annotations: annotationsOf(o, resolve),
+        });
+    }
+    const setNames = new Set(setDrafts.map((s) => s.name));
+    // Pass 2: navigations.
+    const navsByType = new Map();
+    for (const [qualified, navDrafts] of navsDraftByType) {
+        const list = [];
+        for (const nd of navDrafts) {
+            const o = nd.raw;
+            const collection = o["$Collection"] === true;
+            const targetDraft = typeDrafts.get(nd.targetType);
+            if (!targetDraft) {
+                throw new SchemaError(`unknown entity type '${nd.targetType}'`, `${nd.path}/$Type`);
+            }
+            let target;
+            for (const s of setDrafts) {
+                if (s.typeName !== nd.typeName)
+                    continue;
+                const t = s.bindings.get(nd.name);
+                if (t === undefined)
+                    continue;
+                if (!setNames.has(t)) {
+                    throw new SchemaError(`binding targets unknown entity set '${t}'`, `${s.path}/$NavigationPropertyBinding/${nd.name}`);
+                }
+                target = t;
+                break;
+            }
+            if (target === undefined) {
+                const candidates = setDrafts.filter((s) => s.typeName === nd.targetType);
+                if (candidates.length > 1) {
+                    throw new SchemaError("no navigation binding and several entity sets of the target type", nd.path);
+                }
+                // Contained targets have no set of their own.
+                target = candidates[0]?.name ?? targetDraft.name;
+            }
+            const own = constraintPairs(o["$ReferentialConstraint"], `${nd.path}/$ReferentialConstraint`);
+            let keys = own;
+            const partner = str(o["$Partner"]);
+            if (own.length === 0 && collection && partner !== undefined) {
+                const partnerJson = chain(targetDraft).map((d) => d.json[partner]).find(isObject);
+                if (partnerJson) {
+                    keys = constraintPairs(partnerJson["$ReferentialConstraint"], `${targetDraft.path}/${partner}/$ReferentialConstraint`).map(([dependent, principal]) => [principal, dependent]);
+                }
+            }
+            const nav = {
+                name: nd.name,
+                target,
+                collection,
+                keys: keys.map((k) => Object.freeze(k)),
+                ...(partner !== undefined ? { partner } : {}),
+                owned: annotationsOf(o, resolve)["AsterData.Owned"] === true,
+            };
+            list.push(Object.freeze(nav));
+        }
+        navsByType.set(qualified, list);
+    }
+    const types = new FrozenMap();
+    for (const [qualified, draft] of typeDrafts) {
+        const fields = Object.freeze(fieldsByType.get(qualified));
+        const navigations = Object.freeze(navsByType.get(qualified));
+        const fieldMap = new Map(fields.map((f) => [f.name, f]));
+        const navMap = new Map(navigations.map((n) => [n.name, n]));
+        const ann = typeAnnotations.get(qualified);
+        const title = str(ann["Core.Description"]);
+        const pluralTitle = str(ann["AsterData.PluralTitle"]);
+        const titleField = str(ann["AsterData.TitleField"]);
+        const type = {
+            name: draft.name,
+            qualifiedName: qualified,
+            key: Object.freeze([...keysByType.get(qualified)]),
+            fields,
+            navigations,
+            ...(title !== undefined ? { title } : {}),
+            ...(pluralTitle !== undefined ? { pluralTitle } : {}),
+            ...(titleField !== undefined ? { titleField } : {}),
+            annotations: Object.freeze(ann),
+            field: (n) => fieldMap.get(n),
+            navigation: (n) => navMap.get(n),
+        };
+        types.set(qualified, Object.freeze(type));
+    }
+    const sets = new FrozenMap();
+    for (const sd of setDrafts) {
+        const type = types.get(sd.typeName);
+        const oc = sd.annotations["Core.OptimisticConcurrency"];
+        const filterable = recordMember(sd.annotations, "Capabilities.FilterRestrictions", "NonFilterableProperties");
+        const sortable = recordMember(sd.annotations, "Capabilities.SortRestrictions", "NonSortableProperties");
+        const t = sd.annotations["AsterData.CountThreshold"];
+        const threshold = typeof t === "number" || typeof t === "string" ? Number(t) : Number.NaN;
+        sets.set(sd.name, Object.freeze({
+            name: sd.name,
+            type,
+            etag: Array.isArray(oc),
+            nonFilterable: frozenSet(propertyPaths(filterable)),
+            nonSortable: frozenSet(propertyPaths(sortable)),
+            ...(Number.isFinite(threshold) && threshold >= 0 ? { countThreshold: threshold } : {}),
+            annotations: Object.freeze(sd.annotations),
+        }));
+    }
+    types.seal();
+    sets.seal();
+    return Object.freeze({
+        namespace,
+        sets,
+        types,
+        skipped: Object.freeze(skipped),
+        set(name) {
+            const s = sets.get(name);
+            if (!s)
+                throw new SchemaError(`no entity set '${name}'`, `/${containerName}`);
+            return s;
+        },
+    });
+}
+/** Why a property can't be modelled here, or undefined if it can. */
+function unmodelled(o) {
+    const type = o["$Type"] ?? "Edm.String";
+    if (o["$Collection"] === true)
+        return "a collection-valued property";
+    if (typeof type !== "string")
+        return "a property without a type name";
+    switch (type) {
+        case "Edm.Stream":
+            return "a stream";
+        case "Edm.Untyped":
+            return "an untyped value";
+        default:
+            return EDM_TYPES.has(type) ? undefined : `type ${type}`;
+    }
+}
+/** A member of a record-valued annotation, or the flattened `Term.Member` key. */
+function recordMember(ann, term, member) {
+    const rec = ann[term];
+    if (isObject(rec) && rec[member] !== undefined)
+        return rec[member];
+    return ann[`${term}.${member}`];
+}
+function constraintPairs(v, path) {
+    if (v === undefined)
+        return [];
+    const o = obj(v, path);
+    return Object.entries(o).map(([dependent, principal]) => {
+        if (typeof principal !== "string")
+            throw new SchemaError("expected a string", `${path}/${dependent}`);
+        return [dependent, principal];
+    });
+}
+function parseField(name, o, path, resolve) {
+    const type = o["$Type"] ?? "Edm.String";
+    const ann = annotationsOf(o, resolve);
+    const maxLength = optInt(o, "$MaxLength", path);
+    const precision = optInt(o, "$Precision", path);
+    const scale = optInt(o, "$Scale", path);
+    const title = str(ann["Core.Description"]);
+    const prompt = str(ann["Core.LongDescription"]);
+    const pattern = str(ann["Validation.Pattern"]);
+    const minLength = num(ann["AsterData.MinLength"]);
+    let allowedValues;
+    const av = ann["Validation.AllowedValues"];
+    if (av !== undefined) {
+        const ap = `${path}/@Validation.AllowedValues`;
+        if (!Array.isArray(av))
+            throw new SchemaError("expected an array", ap);
+        allowedValues = av.map((item, i) => {
+            const io = obj(item, `${ap}/${i}`);
+            const label = str(annotationsOf(io, resolve)["Core.Description"]);
+            return Object.freeze({
+                value: toValue(io["Value"], `${ap}/${i}/Value`),
+                ...(label !== undefined ? { label } : {}),
+            });
+        });
+    }
+    const bound = (v, term) => {
+        if (v === undefined)
+            return undefined;
+        if (typeof v !== "number" && typeof v !== "string") {
+            throw new SchemaError("expected a number or string", `${path}/@${term}`);
+        }
+        return v;
+    };
+    const minimum = bound(ann["Validation.Minimum"], "Validation.Minimum");
+    const maximum = bound(ann["Validation.Maximum"], "Validation.Maximum");
+    const exMin = ann["Validation.Minimum@Validation.Exclusive"];
+    const exMax = ann["Validation.Maximum@Validation.Exclusive"];
+    const defaultValue = o["$DefaultValue"] === undefined ? undefined : toValue(o["$DefaultValue"], `${path}/$DefaultValue`);
+    const rootValue = ann["AsterData.RootValue"] === undefined ? undefined : toValue(ann["AsterData.RootValue"], `${path}/@AsterData.RootValue`);
+    return Object.freeze({
+        name,
+        type: type,
+        nullable: optBool(o, "$Nullable", path) ?? false,
+        ...(maxLength !== undefined ? { maxLength } : {}),
+        ...(precision !== undefined ? { precision } : {}),
+        ...(scale !== undefined ? { scale } : {}),
+        ...(title !== undefined ? { title } : {}),
+        ...(prompt !== undefined ? { prompt } : {}),
+        computed: ann["Core.Computed"] === true,
+        immutable: ann["Core.Immutable"] === true,
+        ...(allowedValues !== undefined ? { allowedValues: Object.freeze(allowedValues) } : {}),
+        ...(pattern !== undefined ? { pattern } : {}),
+        ...(minimum !== undefined ? { minimum } : {}),
+        ...(maximum !== undefined ? { maximum } : {}),
+        ...(exMin === true ? { exclusiveMinimum: true } : {}),
+        ...(exMax === true ? { exclusiveMaximum: true } : {}),
+        ...(minLength !== undefined ? { minLength } : {}),
+        ...(ann["AsterData.EmptyAsNull"] === true ? { emptyAsNull: true } : {}),
+        ...(defaultValue !== undefined ? { defaultValue } : {}),
+        ...(rootValue !== undefined ? { rootValue } : {}),
+        annotations: Object.freeze(ann),
+    });
+}

package/dist/schema/model.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Built only from CSDL JSON `$metadata` (`csdl.ts`).
+ *
+ * Values stay in their OData JSON form (`IEEE754Compatible=true`) so nothing
+ * loses precision:
+ *
+ * | Edm type                         | JS value                         |
+ * |----------------------------------|----------------------------------|
+ * | String, Guid, Duration           | `string`                         |
+ * | Boolean                          | `boolean`                        |
+ * | Byte, SByte, Int16, Int32        | `number`                         |
+ * | Single, Double                   | `number`                         |
+ * | Int64, Decimal                   | `string` (exact decimal text)    |
+ * | Date                             | `string` `YYYY-MM-DD`            |
+ * | TimeOfDay                        | `string` `hh:mm:ss[.fff]`        |
+ * | DateTimeOffset                   | `string` RFC 3339 with offset    |
+ * | Binary                           | `string` base64url               |
+ * | null                             | `null`                           |
+ */
+export type EdmType = "Edm.String" | "Edm.Boolean" | "Edm.Byte" | "Edm.SByte" | "Edm.Int16" | "Edm.Int32" | "Edm.Int64" | "Edm.Single" | "Edm.Double" | "Edm.Decimal" | "Edm.Date" | "Edm.TimeOfDay" | "Edm.DateTimeOffset" | "Edm.Duration" | "Edm.Guid" | "Edm.Binary";
+export type Value = string | number | boolean | null;
+/** A record as the data core holds it: property name to value. */
+export type Entity = Readonly<Record<string, Value>>;
+/**
+ * Annotations by qualified term name, with namespace aliases resolved to the
+ * alias the vocabulary is known by here: `Core.Description`,
+ * `Validation.Minimum`, `AsterData.DisplayField`.
+ */
+export type Annotations = Readonly<Record<string, unknown>>;
+export interface AllowedValue {
+    readonly value: Value;
+    /** `Core.Description` on the allowed value: the label to show. */
+    readonly label?: string;
+}
+export interface Field {
+    readonly name: string;
+    readonly type: EdmType;
+    readonly nullable: boolean;
+    readonly maxLength?: number;
+    readonly precision?: number;
+    readonly scale?: number;
+    /** `Core.Description`. */
+    readonly title?: string;
+    /** `Core.LongDescription`. */
+    readonly prompt?: string;
+    /** `Core.Computed`: the server assigns it. */
+    readonly computed: boolean;
+    /** `Core.Immutable`: settable on create only. */
+    readonly immutable: boolean;
+    /** `Validation.AllowedValues`. */
+    readonly allowedValues?: readonly AllowedValue[];
+    /** `Validation.Pattern`. */
+    readonly pattern?: string;
+    /** `Validation.Minimum` / `Validation.Maximum`, as written in metadata. */
+    readonly minimum?: number | string;
+    readonly maximum?: number | string;
+    /** `Validation.Exclusive` on the minimum or maximum. */
+    readonly exclusiveMinimum?: boolean;
+    readonly exclusiveMaximum?: boolean;
+    /** `AsterData.MinLength`. */
+    readonly minLength?: number;
+    /** `AsterData.EmptyAsNull`: empty text entered becomes null. */
+    readonly emptyAsNull?: boolean;
+    /** `$DefaultValue`: what the server stores when a create leaves the field out. */
+    readonly defaultValue?: Value;
+    /** `AsterData.RootValue`, on a parent field: the value a root node holds. */
+    readonly rootValue?: Value;
+    readonly annotations: Annotations;
+}
+export interface Navigation {
+    readonly name: string;
+    /** The entity set the navigation leads to. */
+    readonly target: string;
+    readonly collection: boolean;
+    /** `[property of this type, property of the target]` pairs. */
+    readonly keys: readonly (readonly [string, string])[];
+    readonly partner?: string;
+    /**
+     * `AsterData.Owned`: children can't exist without the parent, and are
+     * saved with it through deep insert and deep update with `@delta`.
+     */
+    readonly owned: boolean;
+}
+export interface EntityType {
+    readonly name: string;
+    readonly qualifiedName: string;
+    /** Key property names, in key order. */
+    readonly key: readonly string[];
+    /** In declaration order. */
+    readonly fields: readonly Field[];
+    readonly navigations: readonly Navigation[];
+    /** `Core.Description` on the type. */
+    readonly title?: string;
+    /** `AsterData.PluralTitle`. */
+    readonly pluralTitle?: string;
+    /** `AsterData.TitleField`. */
+    readonly titleField?: string;
+    readonly annotations: Annotations;
+    field(name: string): Field | undefined;
+    navigation(name: string): Navigation | undefined;
+}
+export interface EntitySet {
+    readonly name: string;
+    readonly type: EntityType;
+    /** `Core.OptimisticConcurrency` is present: writes need `If-Match`. */
+    readonly etag: boolean;
+    /** `Capabilities.FilterRestrictions/NonFilterableProperties`. */
+    readonly nonFilterable: ReadonlySet<string>;
+    /** `Capabilities.SortRestrictions/NonSortableProperties`. */
+    readonly nonSortable: ReadonlySet<string>;
+    /**
+     * `AsterData.CountThreshold`: below this many results the server's count
+     * is exact; at or above it, it's estimated or left out unless a
+     * collection asks for `exactCount`.
+     */
+    readonly countThreshold?: number;
+    readonly annotations: Annotations;
+}
+/** A part of `$metadata` the client can't model and left out. */
+export interface Skipped {
+    readonly path: string;
+    readonly reason: string;
+}
+export interface Schema {
+    /** The namespace of the entity container. */
+    readonly namespace: string;
+    readonly sets: ReadonlyMap<string, EntitySet>;
+    readonly types: ReadonlyMap<string, EntityType>;
+    readonly skipped: readonly Skipped[];
+    /** Throws if the set doesn't exist. */
+    set(name: string): EntitySet;
+}

package/dist/schema/model.js

@@ -0,0 +1 @@
+export {};