@nyrra/prismantix-cli 0.0.4-next.23 → 0.0.4-next.25

package/dist/foundry-import/parse.js

@@ -1,8 +1,14 @@
 import { arrayField, isRecord } from "./utils.js";
+const baseTypeFields = ["baseType", "dataType", "type"];
+const dataTypeFields = ["dataType", "type"];
+const interfaceTypeFields = ["type", "dataType", "fieldType"];
 export function parseFoundryV2Export(input, diagnostics) {
     if (!isRecord(input)) {
         throw new Error("Expected a JSON object.");
     }
+    if (isFoundryFullMetadataExport(input)) {
+        return parseFoundryFullMetadataExport(input, diagnostics);
+    }
     const version = typeof input.version === "number" ? input.version : 0;
     addVersionDiagnostic(version, input.version, diagnostics);
     return {
@@ -15,6 +21,520 @@ export function parseFoundryV2Export(input, diagnostics) {
         version,
     };
 }
+function isFoundryFullMetadataExport(input) {
+    const objectTypes = input.objectTypes;
+    return (isRecord(objectTypes) &&
+        Object.values(objectTypes).some((value) => isRecord(value) && isRecord(value.objectType)));
+}
+function parseFoundryFullMetadataExport(input, diagnostics) {
+    const objectTypes = recordField(input, "objectTypes");
+    return {
+        actionTypes: recordValues(input, "actionTypes").map(fullMetadataActionType),
+        interfaces: recordValues(input, "interfaceTypes").map(fullMetadataInterface),
+        objectTypes: Object.values(objectTypes).map(fullMetadataObjectType),
+        relations: fullMetadataRelations(objectTypes, diagnostics),
+        sharedProperties: recordValues(input, "sharedPropertyTypes").map(fullMetadataSharedProperty),
+        typeGroups: arrayField(input, "typeGroups"),
+        version: 2,
+    };
+}
+function fullMetadataObjectType(value) {
+    const wrapper = isRecord(value) ? value : {};
+    const objectType = isRecord(wrapper.objectType)
+        ? wrapper.objectType
+        : wrapper;
+    return {
+        aliases: stringArray(objectType.aliases),
+        apiName: stringField(objectType, "apiName"),
+        datasources: arrayField(objectType, "datasources"),
+        displayMetadata: fullMetadataDisplayMetadata(objectType),
+        interfaces: fullMetadataObjectInterfaces(wrapper),
+        interfaceImplementations: fullMetadataObjectInterfaceImplementations(wrapper),
+        primaryKeys: fullMetadataPrimaryKeys(objectType),
+        properties: recordEntries(objectType, "properties").map(([key, property]) => fullMetadataProperty(key, property)),
+        rid: stringField(objectType, "rid"),
+        status: fullMetadataStatus(objectType.status),
+        titlePropertyId: fullMetadataTitleProperty(objectType),
+        typeGroups: stringArray(objectType.typeGroups),
+    };
+}
+function fullMetadataPrimaryKeys(objectType) {
+    const primaryKey = stringField(objectType, "primaryKey");
+    return primaryKey ? [primaryKey] : stringArray(objectType.primaryKeys);
+}
+function fullMetadataTitleProperty(objectType) {
+    return firstStringField(objectType, ["titleProperty", "titlePropertyId"]);
+}
+function fullMetadataObjectInterfaces(wrapper) {
+    const implementsInterfaces = stringArray(wrapper.implementsInterfaces);
+    if (implementsInterfaces.length > 0) {
+        return implementsInterfaces;
+    }
+    const implementsInterfaces2 = wrapper.implementsInterfaces2;
+    return isRecord(implementsInterfaces2)
+        ? Object.keys(implementsInterfaces2)
+        : [];
+}
+function fullMetadataObjectInterfaceImplementations(wrapper) {
+    const implementsInterfaces2 = wrapper.implementsInterfaces2;
+    if (!isRecord(implementsInterfaces2)) {
+        return [];
+    }
+    return Object.entries(implementsInterfaces2).map(([interfaceApiName, implementation]) => ({
+        interfaceApiName: fullMetadataImplementationApiName(interfaceApiName, implementation),
+        propertyMappings: fullMetadataObjectInterfacePropertyMappings(implementation),
+    }));
+}
+function fullMetadataImplementationApiName(interfaceApiName, implementation) {
+    const record = isRecord(implementation) ? implementation : {};
+    return stringField(record, "apiName") ?? interfaceApiName;
+}
+function fullMetadataObjectInterfacePropertyMappings(implementation) {
+    const record = isRecord(implementation) ? implementation : {};
+    const propertiesV2 = recordField(record, "propertiesV2");
+    const v2Entries = Object.entries(propertiesV2).flatMap(([interfacePropertyApiName, mapping]) => {
+        const objectPropertyApiName = fullMetadataPropertyMappingTarget(mapping);
+        return objectPropertyApiName
+            ? [{ interfacePropertyApiName, objectPropertyApiName }]
+            : [];
+    });
+    if (v2Entries.length > 0) {
+        return v2Entries;
+    }
+    return recordEntries(record, "properties").flatMap(([interfacePropertyApiName, objectPropertyApiName]) => typeof objectPropertyApiName === "string"
+        ? [{ interfacePropertyApiName, objectPropertyApiName }]
+        : []);
+}
+function fullMetadataPropertyMappingTarget(mapping) {
+    if (typeof mapping === "string") {
+        return mapping;
+    }
+    const record = isRecord(mapping) ? mapping : {};
+    return (stringField(record, "propertyApiName") ??
+        stringField(record, "propertyTypeRid"));
+}
+function fullMetadataProperty(apiName, value) {
+    const property = isRecord(value) ? value : {};
+    return {
+        apiName: stringFieldWithFallback(property, "apiName", apiName),
+        baseFormatter: property.baseFormatter,
+        baseType: fullMetadataBaseType(firstPresentValue(property, baseTypeFields)),
+        dataConstraints: dataConstraints(property),
+        displayMetadata: fullMetadataDisplayMetadata(property),
+        id: stringFieldWithFallback(property, "id", apiName),
+        indexedForSearch: booleanField(property, "indexedForSearch"),
+        renderHints: renderHints(property),
+        rid: stringField(property, "rid"),
+        source: recordOrUndefined(property.source),
+        status: fullMetadataStatus(property.status),
+        typeClasses: arrayField(property, "typeClasses"),
+        valueType: fullMetadataValueType(property),
+    };
+}
+function fullMetadataActionType(value) {
+    const action = isRecord(value) ? value : {};
+    const operations = arrayField(action, "operations").map(fullMetadataActionOperation);
+    return {
+        actionTypeLogic: {
+            logic: {
+                rules: operations.map((operation) => ({
+                    objectTypeApiName: operation.objectTypeApiName,
+                    type: operation.type,
+                })),
+            },
+        },
+        metadata: {
+            apiName: stringField(action, "apiName"),
+            displayMetadata: fullMetadataDisplayMetadata(action),
+            formContentInOrder: recordEntries(action, "parameters").map(([id, parameter]) => ({
+                parameter: fullMetadataActionParameter(id, parameter),
+                type: "parameter",
+            })),
+            rid: stringField(action, "rid"),
+            status: fullMetadataStatus(action.status),
+        },
+        operations,
+    };
+}
+function fullMetadataActionOperation(value) {
+    const operation = isRecord(value) ? value : {};
+    return {
+        objectTypeApiName: stringField(operation, "objectTypeApiName"),
+        type: stringField(operation, "type"),
+    };
+}
+function fullMetadataActionParameter(id, value) {
+    const parameter = isRecord(value) ? value : {};
+    return {
+        displayMetadata: fullMetadataDisplayMetadata(parameter),
+        id,
+        required: booleanField(parameter, "required"),
+        type: fullMetadataBaseType(firstPresentValue(parameter, dataTypeFields)),
+    };
+}
+function fullMetadataInterface(value) {
+    const interfaceType = isRecord(value) ? value : {};
+    return {
+        apiName: stringField(interfaceType, "apiName"),
+        displayMetadata: fullMetadataDisplayMetadata(interfaceType),
+        extendsInterfaces: stringArray(interfaceType.extendsInterfaces),
+        links: recordOrArrayEntries(interfaceType.links).map(([key, link]) => fullMetadataInterfaceLink(key, link)),
+        properties: recordOrArrayEntries(interfaceType.properties).map(([key, property]) => fullMetadataInterfaceProperty(key, property)),
+        rid: stringField(interfaceType, "rid"),
+        searchable: booleanField(interfaceType, "searchable"),
+        status: fullMetadataStatus(interfaceType.status),
+    };
+}
+function fullMetadataInterfaceProperty(apiName, value) {
+    const property = isRecord(value) ? value : {};
+    return {
+        apiName: stringFieldWithFallback(property, "apiName", apiName),
+        displayName: stringField(property, "displayName"),
+        isSharedProperty: booleanField(property, "isSharedProperty"),
+        required: firstBooleanField(property, [
+            "required",
+            "requireImplementation",
+        ]),
+        sharedPropertyRid: stringField(property, "sharedPropertyRid"),
+        type: fullMetadataBaseType(firstPresentValue(property, interfaceTypeFields)),
+    };
+}
+function fullMetadataInterfaceLink(apiName, value) {
+    const link = isRecord(value) ? value : {};
+    const linkedEntity = isRecord(link.linkedEntityApiName)
+        ? link.linkedEntityApiName
+        : {};
+    return {
+        apiName: stringFieldWithFallback(link, "apiName", apiName),
+        cardinality: stringField(link, "cardinality"),
+        description: nullableStringField(link, "description") ?? undefined,
+        displayName: stringField(link, "displayName"),
+        linkedEntityApiName: stringField(linkedEntity, "apiName"),
+        linkedEntityType: stringField(linkedEntity, "type"),
+        required: booleanField(link, "required"),
+        rid: stringField(link, "rid"),
+    };
+}
+function fullMetadataSharedProperty(value) {
+    const property = isRecord(value) ? value : {};
+    return {
+        aliases: stringArray(property.aliases),
+        apiName: stringField(property, "apiName"),
+        baseType: fullMetadataBaseType(firstPresentValue(property, baseTypeFields)),
+        dataConstraints: dataConstraints(property),
+        displayMetadata: fullMetadataDisplayMetadata(property),
+        indexedForSearch: booleanField(property, "indexedForSearch"),
+        renderHints: renderHints(property),
+        rid: stringField(property, "rid"),
+        valueType: fullMetadataValueType(property),
+    };
+}
+function fullMetadataRelations(objectTypes, diagnostics) {
+    const groups = fullMetadataLinkGroups(objectTypes);
+    return [...groups.entries()].flatMap(([relationRid, links], relationIndex) => fullMetadataRelation(relationRid, links, relationIndex, diagnostics));
+}
+function fullMetadataLinkGroups(objectTypes) {
+    const groups = new Map();
+    for (const value of Object.values(objectTypes)) {
+        addFullMetadataObjectLinks(groups, value);
+    }
+    return groups;
+}
+function addFullMetadataObjectLinks(groups, value) {
+    const wrapper = isRecord(value) ? value : {};
+    const context = fullMetadataLinkContext(wrapper);
+    if (!context) {
+        return;
+    }
+    for (const link of arrayField(wrapper, "linkTypes")) {
+        addFullMetadataLink(groups, context, link);
+    }
+}
+function addFullMetadataLink(groups, context, value) {
+    const linkRecord = isRecord(value) ? value : {};
+    const relationRid = fullMetadataRelationRid(context.sourceApiName, linkRecord);
+    const group = groups.get(relationRid) ?? [];
+    group.push({ link: linkRecord, ...context });
+    groups.set(relationRid, group);
+}
+function fullMetadataLinkContext(wrapper) {
+    const objectType = fullMetadataWrappedObjectType(wrapper);
+    const sourceApiName = stringField(objectType, "apiName");
+    const sourceRid = stringField(objectType, "rid");
+    return sourceApiName && sourceRid ? { sourceApiName, sourceRid } : undefined;
+}
+function fullMetadataRelationRid(sourceApiName, link) {
+    return (stringField(link, "linkTypeRid") ??
+        `${sourceApiName}:${stringFieldWithFallback(link, "apiName", "link")}`);
+}
+function fullMetadataRelation(relationRid, links, relationIndex, diagnostics) {
+    if (links.length !== 2) {
+        diagnostics.push({
+            code: "skipped.fullMetadataLinkGroup",
+            message: `Foundry full-metadata link group ${relationRid} has ${links.length} sides; expected 2.`,
+            path: `$.objectTypes.*.linkTypes[${relationIndex}]`,
+            severity: "warning",
+        });
+        return [];
+    }
+    const foreignKeySide = links.find((link) => Boolean(stringField(link.link, "foreignKeyPropertyApiName")));
+    if (foreignKeySide) {
+        return fullMetadataOneToManyRelation(relationRid, links, foreignKeySide);
+    }
+    return [fullMetadataManyToManyRelation(relationRid, linkPair(links))];
+}
+function fullMetadataManyToManyRelation(relationRid, [a, b]) {
+    return {
+        definition: {
+            manyToMany: {
+                objectTypeAToBLinkMetadata: fullMetadataLinkMetadata(a.link),
+                objectTypeBToALinkMetadata: fullMetadataLinkMetadata(b.link),
+                objectTypeRidA: a.sourceRid,
+                objectTypeRidB: b.sourceRid,
+            },
+            type: "manyToMany",
+        },
+        id: relationRid,
+        rid: relationRid,
+        status: fullMetadataStatus(firstPresentValueFromList([a.link, b.link], "status")),
+    };
+}
+function fullMetadataOneToManyRelation(relationRid, links, foreignKeySide) {
+    const oneSide = links.find((link) => link !== foreignKeySide);
+    if (!oneSide) {
+        return [];
+    }
+    return [
+        {
+            definition: {
+                oneToMany: {
+                    cardinalityHint: stringField(oneSide.link, "cardinality") === "ONE"
+                        ? "ONE_TO_ONE"
+                        : "ONE_TO_MANY",
+                    manySideForeignKeyPropertyId: stringField(foreignKeySide.link, "foreignKeyPropertyApiName"),
+                    manyToOneLinkMetadata: fullMetadataLinkMetadata(foreignKeySide.link),
+                    objectTypeRidManySide: foreignKeySide.sourceRid,
+                    objectTypeRidOneSide: oneSide.sourceRid,
+                    oneToManyLinkMetadata: fullMetadataLinkMetadata(oneSide.link),
+                },
+                type: "oneToMany",
+            },
+            id: relationRid,
+            rid: relationRid,
+            status: fullMetadataStatus(foreignKeySide.link.status ?? oneSide.link.status),
+        },
+    ];
+}
+function fullMetadataLinkMetadata(link) {
+    return {
+        apiName: stringField(link, "apiName"),
+        displayMetadata: fullMetadataDisplayMetadata(link),
+        typeClasses: arrayField(link, "typeClasses"),
+    };
+}
+function fullMetadataWrappedObjectType(value) {
+    const wrapper = isRecord(value) ? value : {};
+    return isRecord(wrapper.objectType) ? wrapper.objectType : wrapper;
+}
+function fullMetadataBaseType(value) {
+    const record = recordOrUndefined(value);
+    return record ? fullMetadataBaseTypeFromRecord(record) : undefined;
+}
+function fullMetadataBaseTypeFromRecord(value) {
+    const type = stringField(value, "type");
+    return type
+        ? typedFullMetadataBaseType(value, type)
+        : value;
+}
+function typedFullMetadataBaseType(value, type) {
+    const normalizedType = normalizeFullMetadataType(type);
+    return {
+        ...value,
+        ...fullMetadataBaseTypeExtras(value, normalizedType),
+        type: normalizedType,
+    };
+}
+function fullMetadataBaseTypeExtras(value, type) {
+    const extras = {
+        ARRAY: () => ({ subType: fullMetadataBaseType(value.subType) }),
+        STRUCT: () => ({
+            structFields: recordOrArrayValues(value.fields).map((field) => fullMetadataStructField(field)),
+        }),
+    };
+    return extras[type]?.() ?? {};
+}
+function fullMetadataStructField(value) {
+    const field = isRecord(value) ? value : {};
+    return {
+        apiName: stringField(field, "apiName") ?? stringField(field, "name"),
+        displayMetadata: fullMetadataDisplayMetadata(field),
+        fieldType: fullMetadataBaseType(field.fieldType ?? field.dataType),
+    };
+}
+function normalizeFullMetadataType(type) {
+    const typeMap = {
+        array: "ARRAY",
+        attachment: "ATTACHMENT",
+        boolean: "BOOLEAN",
+        date: "DATE",
+        double: "DOUBLE",
+        geohash: "GEOHASH",
+        geopoint: "GEOHASH",
+        geoshape: "GEOSHAPE",
+        integer: "INTEGER",
+        long: "LONG",
+        marking: "MARKING",
+        mediaReference: "MEDIA_REFERENCE",
+        string: "STRING",
+        struct: "STRUCT",
+        timestamp: "TIMESTAMP",
+        vector: "VECTOR",
+    };
+    return typeMap[type] ?? type;
+}
+function fullMetadataStatus(value) {
+    const type = fullMetadataStatusType(value);
+    return type
+        ? { ...fullMetadataStatusRecord(value), type: type.toLowerCase() }
+        : undefined;
+}
+function fullMetadataStatusRecord(value) {
+    return isRecord(value) ? value : {};
+}
+function fullMetadataStatusType(value) {
+    return typeof value === "string"
+        ? nonEmptyString(value)
+        : stringField(fullMetadataStatusRecord(value), "type");
+}
+function fullMetadataDisplayMetadata(record) {
+    const nested = recordOrUndefined(record.displayMetadata);
+    return nested ? nested : displayMetadataFromTopLevelFields(record);
+}
+function displayMetadataFromTopLevelFields(record) {
+    const displayMetadata = {
+        description: nullableStringField(record, "description"),
+        displayName: nullableStringField(record, "displayName"),
+        groupDisplayName: nullableStringField(record, "groupDisplayName"),
+        icon: definedValue(record.icon),
+        pluralDisplayName: nullableStringField(record, "pluralDisplayName"),
+        visibility: nullableStringField(record, "visibility"),
+    };
+    const compact = compactRecord(displayMetadata);
+    return Object.keys(compact).length > 0
+        ? compact
+        : undefined;
+}
+function linkPair(links) {
+    return [links[0], links[1]];
+}
+function fullMetadataValueType(record) {
+    const explicit = record.valueType;
+    return explicit === undefined ? valueTypeReference(record) : explicit;
+}
+function firstPresentValue(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function firstPresentValueFromList(records, key) {
+    for (const record of records) {
+        const value = record[key];
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function firstStringField(record, keys) {
+    for (const key of keys) {
+        const value = stringField(record, key);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function firstBooleanField(record, keys) {
+    for (const key of keys) {
+        const value = booleanField(record, key);
+        if (value !== undefined) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function stringFieldWithFallback(record, key, fallback) {
+    return stringField(record, key) ?? fallback;
+}
+function recordOrUndefined(value) {
+    return isRecord(value) ? value : undefined;
+}
+function nonEmptyString(value) {
+    return value === "" ? undefined : value;
+}
+function nullableStringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" || value === null ? value : undefined;
+}
+function definedValue(value) {
+    return value === undefined ? undefined : value;
+}
+function compactRecord(record) {
+    return Object.fromEntries(Object.entries(record).filter((entry) => entry[1] !== undefined));
+}
+function dataConstraints(record) {
+    return isRecord(record.dataConstraints) ? record.dataConstraints : undefined;
+}
+function valueTypeReference(record) {
+    const valueTypeApiName = stringField(record, "valueTypeApiName");
+    return valueTypeApiName ? { apiName: valueTypeApiName } : undefined;
+}
+function renderHints(record) {
+    const explicit = stringArray(record.renderHints);
+    if (explicit.length > 0) {
+        return explicit;
+    }
+    return arrayField(record, "typeClasses").flatMap((typeClass) => typeClass.kind === "render_hint" && typeClass.name ? [typeClass.name] : []);
+}
+function recordField(record, key) {
+    const value = record[key];
+    return isRecord(value) ? value : {};
+}
+function recordValues(record, key) {
+    return Object.values(recordField(record, key));
+}
+function recordEntries(record, key) {
+    return Object.entries(recordField(record, key));
+}
+function recordOrArrayValues(value) {
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return isRecord(value) ? Object.values(value) : [];
+}
+function recordOrArrayEntries(value) {
+    if (Array.isArray(value)) {
+        return value.map((item, index) => [String(index), item]);
+    }
+    return isRecord(value) ? Object.entries(value) : [];
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+function booleanField(record, key) {
+    const value = record[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
 function addVersionDiagnostic(version, rawVersion, diagnostics) {
     if (version === 2) {
         return;

package/dist/foundry-import/types.d.ts

@@ -71,6 +71,7 @@ export interface FoundryObjectType {
     readonly displayMetadata?: FoundryDisplayMetadata;
     readonly id?: string;
     readonly interfaces?: readonly string[];
+    readonly interfaceImplementations?: readonly FoundryObjectInterfaceImplementation[];
     readonly primaryKeys?: readonly string[];
     readonly properties?: readonly FoundryProperty[];
     readonly rid?: string;
@@ -79,6 +80,14 @@ export interface FoundryObjectType {
     readonly typeGroups?: readonly string[];
     readonly [key: string]: unknown;
 }
+export interface FoundryObjectInterfaceImplementation {
+    readonly interfaceApiName: string;
+    readonly propertyMappings: readonly FoundryObjectInterfacePropertyMapping[];
+}
+export interface FoundryObjectInterfacePropertyMapping {
+    readonly interfacePropertyApiName: string;
+    readonly objectPropertyApiName: string;
+}
 export interface FoundryLinkMetadata {
     readonly apiName?: string;
     readonly displayMetadata?: FoundryDisplayMetadata;
@@ -121,17 +130,25 @@ export interface FoundryRelation {
 export interface FoundryActionParameter {
     readonly displayMetadata?: FoundryDisplayMetadata;
     readonly id?: string;
+    readonly required?: boolean;
     readonly type?: {
         readonly type?: string;
         readonly [key: string]: unknown;
     };
+    readonly validation?: unknown;
+}
+export interface FoundryActionRule {
+    readonly [key: string]: unknown;
+    readonly type?: string;
+}
+export interface FoundryActionOperation {
+    readonly objectTypeApiName?: string;
+    readonly type?: string;
 }
 export interface FoundryActionType {
     readonly actionTypeLogic?: {
         readonly logic?: {
-            readonly rules?: readonly {
-                readonly type?: string;
-            }[];
+            readonly rules?: readonly FoundryActionRule[];
         };
     };
     readonly metadata?: {
@@ -144,19 +161,31 @@ export interface FoundryActionType {
         readonly rid?: string;
         readonly status?: FoundryStatus;
     };
+    readonly operations?: readonly FoundryActionOperation[];
 }
 export interface FoundryInterfaceProperty {
+    readonly apiName?: string;
     readonly displayName?: string;
     readonly isSharedProperty?: boolean;
     readonly required?: boolean;
     readonly sharedPropertyRid?: string;
     readonly type?: FoundryBaseType;
 }
+export interface FoundryInterfaceLink {
+    readonly apiName?: string;
+    readonly cardinality?: string;
+    readonly description?: string;
+    readonly displayName?: string;
+    readonly linkedEntityApiName?: string;
+    readonly linkedEntityType?: string;
+    readonly required?: boolean;
+    readonly rid?: string;
+}
 export interface FoundryInterface {
     readonly apiName?: string;
     readonly displayMetadata?: FoundryDisplayMetadata;
     readonly extendsInterfaces?: readonly string[];
-    readonly links?: readonly unknown[];
+    readonly links?: readonly FoundryInterfaceLink[];
     readonly properties?: readonly FoundryInterfaceProperty[];
     readonly rid?: string;
     readonly searchable?: boolean;
@@ -202,6 +231,8 @@ export interface NormalizedObject {
     readonly apiName: NamePair;
     readonly description?: string;
     readonly displayName: string;
+    readonly id?: string;
+    readonly interfaceImplementations: readonly NormalizedObjectInterfaceImplementation[];
     readonly pluralDisplayName: string;
     readonly primaryKeyPropertyApiName: string;
     readonly properties: readonly NormalizedProperty[];
@@ -211,6 +242,15 @@ export interface NormalizedObject {
     readonly titlePropertyApiName: string;
     readonly variableName: string;
 }
+export interface NormalizedObjectInterfaceImplementation {
+    readonly interfaceApiName: NamePair;
+    readonly interfaceVariableName: string;
+    readonly propertyMappings: readonly NormalizedObjectInterfacePropertyMapping[];
+}
+export interface NormalizedObjectInterfacePropertyMapping {
+    readonly interfacePropertyApiName: string;
+    readonly objectPropertyApiName: string;
+}
 export interface NormalizedSharedProperty {
     readonly apiName: NamePair;
     readonly array: boolean;
@@ -230,11 +270,34 @@ export interface NormalizedInterface {
     readonly apiName: NamePair;
     readonly description?: string;
     readonly displayName: string;
+    readonly extendsInterfaces: readonly NormalizedInterfaceReference[];
+    readonly links: readonly NormalizedInterfaceLink[];
+    readonly properties: readonly NormalizedInterfaceProperty[];
     readonly rid?: string;
     readonly searchable: boolean;
     readonly status?: string;
     readonly variableName: string;
 }
+export interface NormalizedInterfaceReference {
+    readonly apiName: NamePair;
+    readonly variableName: string;
+}
+export interface NormalizedInterfaceProperty {
+    readonly apiName: NamePair;
+    readonly displayName: string;
+    readonly required: boolean;
+    readonly sharedPropertyVariableName?: string;
+    readonly type?: unknown;
+}
+export interface NormalizedInterfaceLink {
+    readonly apiName: NamePair;
+    readonly cardinality: "MANY" | "SINGLE";
+    readonly description?: string;
+    readonly displayName: string;
+    readonly required?: boolean;
+    readonly targetApiName: NamePair;
+    readonly targetVariableName: string;
+}
 export interface NormalizedRelation {
     readonly apiName: NamePair;
     readonly definition: unknown;
@@ -246,9 +309,19 @@ export interface NormalizedRelation {
 export interface NormalizedAction {
     readonly apiName: NamePair;
     readonly displayName: string;
-    readonly parameterCount: number;
+    readonly parameters: readonly NormalizedActionParameter[];
     readonly ruleTypes: readonly string[];
+    readonly rules: readonly unknown[];
     readonly status?: string;
+    readonly variableName: string;
+}
+export interface NormalizedActionParameter {
+    readonly description?: string;
+    readonly displayName: string;
+    readonly id: NamePair;
+    readonly required: boolean;
+    readonly type: unknown;
+    readonly validationAllowedValues: unknown;
 }
 export interface NormalizedTypeGroup {
     readonly displayName: string;