@osdk/maker 0.15.0-beta.6 → 0.15.0-beta.8

package/build/cjs/index.cjs

@@ -198,10 +198,7 @@ function convertLink(linkType) {
     linkType: {
       definition,
       id: cleanAndValidateLinkTypeId(linkType.apiName),
-      status: linkType.status ?? {
-        type: "active",
-        active: {}
-      },
+      status: convertLinkStatus(linkType.status),
       redacted: linkType.redacted ?? false
     },
     datasources: datasource !== void 0 ? [datasource] : [],
@@ -255,14 +252,56 @@ function getObject(object) {
     object: fullObject
   };
 }
+function convertLinkStatus(status) {
+  if (typeof status === "object" && "type" in status && status.type === "deprecated") {
+    return {
+      type: "deprecated",
+      deprecated: {
+        message: status.message,
+        deadline: status.deadline
+      }
+    };
+  }
+  switch (status) {
+    case "experimental":
+      return {
+        type: "experimental",
+        experimental: {}
+      };
+    case "example":
+      return {
+        type: "example",
+        example: {}
+      };
+    case "active":
+    default:
+      return {
+        type: "active",
+        active: {}
+      };
+  }
+}
+
+// src/api/interface/InterfacePropertyType.ts
+function isInterfaceSharedPropertyType(interfacePropertyType) {
+  return "sharedPropertyType" in interfacePropertyType;
+}
+function getInterfacePropertyTypeType(interfacePropertyType) {
+  return isInterfaceSharedPropertyType(interfacePropertyType) ? interfacePropertyType.sharedPropertyType.type : interfacePropertyType.type;
+}
 
 // src/api/interface/getFlattenedInterfaceProperties.ts
 function getFlattenedInterfaceProperties(interfaceType) {
-  let properties = interfaceType.propertiesV2;
+  let properties = Object.fromEntries(Object.entries(interfaceType.propertiesV3).map(([key, value]) => [isInterfaceSharedPropertyType(value) ? value.sharedPropertyType.apiName : key, value]));
+  Object.entries(interfaceType.propertiesV2).forEach(([apiName, spt]) => {
+    if (!(apiName in properties)) {
+      properties[apiName] = spt;
+    }
+  });
   interfaceType.extendsInterfaces.forEach((ext) => {
     properties = {
-      ...properties,
-      ...getFlattenedInterfaceProperties(ext)
+      ...getFlattenedInterfaceProperties(ext),
+      ...properties
     };
   });
   return properties;
@@ -279,7 +318,7 @@ function isExotic(type) {
   if (typeof type === "string") {
     return ["geopoint", "geoshape", "mediaReference", "geotimeSeries"].includes(type);
   } else if (typeof type === "object" && type != null) {
-    return type.type === "marking" || type.type === "struct";
+    return type.type === "marking" || type.type === "struct" || type.type === "string" || type.type === "decimal";
   }
   return false;
 }
@@ -328,18 +367,19 @@ function defineObject(objectDef) {
   !!isExotic(objectDef.properties?.[objectDef.primaryKeyPropertyApiName]?.type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Primary key property ${objectDef.primaryKeyPropertyApiName} can only be primitive types`) : invariant7__default.default(false) : void 0;
   objectDef.implementsInterfaces?.forEach((interfaceImpl) => {
     const allInterfaceProperties = getFlattenedInterfaceProperties(interfaceImpl.implements);
-    const nonExistentInterfaceProperties = interfaceImpl.propertyMapping.map((val) => val.interfaceProperty).filter((interfaceProperty) => allInterfaceProperties[addNamespaceIfNone(interfaceProperty)] === void 0).map((interfaceProp) => ({
+    const nonExistentInterfaceProperties = interfaceImpl.propertyMapping.map((val) => val.interfaceProperty).filter((interfaceProperty) => allInterfaceProperties[addNamespaceIfNone(interfaceProperty)] === void 0 && allInterfaceProperties[withoutNamespace(interfaceProperty)] === void 0).map((interfaceProp) => ({
       type: "invalid",
       reason: `Interface property ${interfaceProp} referenced in ${objectDef.apiName} object does not exist`
     }));
-    const interfaceToObjectProperties = Object.fromEntries(interfaceImpl.propertyMapping.map((mapping) => [addNamespaceIfNone(mapping.interfaceProperty), mapping.mapsTo]));
+    const interfaceToObjectProperties = Object.fromEntries(interfaceImpl.propertyMapping.map((mapping) => [mapping.interfaceProperty, mapping.mapsTo]));
     const validateProperty = (interfaceProp) => {
-      if (interfaceProp[1].sharedPropertyType.apiName in interfaceToObjectProperties) {
-        return validateInterfaceImplProperty(interfaceProp[1].sharedPropertyType, interfaceToObjectProperties[interfaceProp[0]], objectDef);
+      const apiName2 = isInterfaceSharedPropertyType(interfaceProp[1]) ? interfaceProp[1].sharedPropertyType.apiName : interfaceProp[0];
+      if (apiName2 in interfaceToObjectProperties) {
+        return validateInterfaceImplProperty(interfaceProp[1], apiName2, interfaceToObjectProperties[interfaceProp[0]], objectDef);
       }
       return {
         type: "invalid",
-        reason: `Interface property ${interfaceProp[1].sharedPropertyType.apiName} not implemented by ${objectDef.apiName} object definition`
+        reason: `Interface spt ${apiName2} not implemented by ${objectDef.apiName} object definition`
       };
     };
     const validations = Object.entries(getFlattenedInterfaceProperties(interfaceImpl.implements)).map(validateProperty);
@@ -361,7 +401,7 @@ function formatValidationErrors(error) {
   return `Ontology Definition Error: ${error.reason}
 `;
 }
-function validateInterfaceImplProperty(spt, mappedObjectProp, object) {
+function validateInterfaceImplProperty(type, apiName, mappedObjectProp, object) {
   const objProp = object.properties?.[mappedObjectProp];
   if (objProp === void 0) {
     return {
@@ -369,10 +409,11 @@ function validateInterfaceImplProperty(spt, mappedObjectProp, object) {
       reason: `Object property mapped to interface does not exist. Object Property Mapped: ${mappedObjectProp}`
     };
   }
-  if (JSON.stringify(spt.type) !== JSON.stringify(objProp?.type)) {
+  const propertyType = getInterfacePropertyTypeType(type);
+  if (JSON.stringify(propertyType) !== JSON.stringify(objProp?.type)) {
     return {
       type: "invalid",
-      reason: `Object property type does not match the interface property it is mapped to. Interface Property: ${spt.apiName}, objectProperty: ${mappedObjectProp}`
+      reason: `Object property type does not match the interface property it is mapped to. Interface Property: ${apiName}, objectProperty: ${mappedObjectProp}`
     };
   }
   return {
@@ -719,7 +760,7 @@ function convertActionValidation(action) {
       return [p.id, {
         defaultValidation: {
           display: {
-            renderHint: renderHintFromBaseType(p, p.validation),
+            renderHint: p.renderHint ?? renderHintFromBaseType(p, p.validation),
             visibility: convertActionVisibility(p.validation.defaultVisibility),
             ...p.defaultValue && {
               prefill: p.defaultValue
@@ -839,6 +880,10 @@ function propertyTypeTypeToOntologyIrType(type) {
               ...fieldTypeDefinition,
               apiName: key,
               fieldType: propertyTypeTypeToOntologyIrType(fieldTypeDefinition.fieldType),
+              displayMetadata: fieldTypeDefinition.displayMetadata ?? {
+                displayName: key,
+                description: void 0
+              },
               typeClasses: fieldTypeDefinition.typeClasses ?? [],
               aliases: fieldTypeDefinition.aliases ?? []
             };
@@ -935,6 +980,7 @@ function convertSpt({
   visibility,
   gothamMapping,
   typeClasses,
+  aliases,
   valueType,
   nullability,
   baseFormatter
@@ -953,10 +999,11 @@ function convertSpt({
     type: array ? {
       type: "array",
       array: {
-        subtype: propertyTypeTypeToOntologyIrType(type)
+        subtype: propertyTypeTypeToOntologyIrType(type),
+        reducers: []
       }
     } : propertyTypeTypeToOntologyIrType(type),
-    aliases: [],
+    aliases: aliases ?? [],
     baseFormatter,
     dataConstraints: dataConstraint,
     gothamMapping,
@@ -971,6 +1018,178 @@ function convertSpt({
   };
 }
 
+// src/conversion/toMarketplace/propertyTypeTypeToOntologyIrInterfaceType.ts
+function propertyTypeTypeToOntologyIrInterfaceType(type) {
+  switch (true) {
+    case (typeof type === "object" && type.type === "marking"):
+      return {
+        "type": "marking",
+        marking: {
+          markingType: type.markingType
+        }
+      };
+    case (typeof type === "object" && type.type === "struct"):
+      const structFields = new Array();
+      for (const key in type.structDefinition) {
+        const fieldTypeDefinition = type.structDefinition[key];
+        let field;
+        if (typeof fieldTypeDefinition === "string") {
+          field = {
+            apiName: key,
+            displayMetadata: {
+              displayName: key,
+              description: void 0
+            },
+            typeClasses: [],
+            aliases: [],
+            fieldType: propertyTypeTypeToOntologyIrInterfaceType(fieldTypeDefinition),
+            requireImplementation: true
+          };
+        } else {
+          if (typeof fieldTypeDefinition === "object" && "fieldType" in fieldTypeDefinition) {
+            field = {
+              ...fieldTypeDefinition,
+              apiName: key,
+              fieldType: propertyTypeTypeToOntologyIrInterfaceType(fieldTypeDefinition.fieldType),
+              displayMetadata: fieldTypeDefinition.displayMetadata ?? {
+                displayName: key,
+                description: void 0
+              },
+              typeClasses: fieldTypeDefinition.typeClasses ?? [],
+              aliases: fieldTypeDefinition.aliases ?? [],
+              requireImplementation: fieldTypeDefinition.requireImplementation ?? true
+            };
+          } else {
+            field = {
+              apiName: key,
+              displayMetadata: {
+                displayName: key,
+                description: void 0
+              },
+              typeClasses: [],
+              aliases: [],
+              fieldType: propertyTypeTypeToOntologyIrInterfaceType(fieldTypeDefinition),
+              requireImplementation: true
+            };
+          }
+        }
+        structFields.push(field);
+      }
+      return {
+        type: "struct",
+        struct: {
+          structFields
+        }
+      };
+    case (typeof type === "object" && type.type === "string"):
+      return {
+        "type": "string",
+        "string": {
+          analyzerOverride: void 0,
+          enableAsciiFolding: type.enableAsciiFolding,
+          isLongText: type.isLongText ?? false,
+          supportsEfficientLeadingWildcard: type.supportsEfficientLeadingWildcard ?? false,
+          supportsExactMatching: type.supportsExactMatching ?? true,
+          supportsFullTextRegex: type.supportsFullTextRegex
+        }
+      };
+    case (typeof type === "object" && type.type === "decimal"):
+      return {
+        "type": "decimal",
+        "decimal": {
+          precision: type.precision,
+          scale: type.scale
+        }
+      };
+    case type === "geopoint":
+      return {
+        type: "geohash",
+        geohash: {}
+      };
+    case type === "decimal":
+      return {
+        type,
+        [type]: {
+          precision: void 0,
+          scale: void 0
+        }
+      };
+    case type === "string":
+      return {
+        type,
+        [type]: {
+          analyzerOverride: void 0,
+          enableAsciiFolding: void 0,
+          isLongText: false,
+          supportsEfficientLeadingWildcard: false,
+          supportsExactMatching: true
+        }
+      };
+    case type === "mediaReference":
+      return {
+        type,
+        mediaReference: {}
+      };
+    case type === "geotimeSeries":
+      return {
+        type: "geotimeSeriesReference",
+        geotimeSeriesReference: {}
+      };
+    default:
+      if (typeof type === "object") {
+        throw new Error(`Unhandled exotic type: ${JSON.stringify(type)}`);
+      }
+      return distributeTypeHelper(type);
+  }
+}
+
+// src/conversion/toMarketplace/convertInterfacePropertyType.ts
+function convertInterfaceProperty(prop, apiName) {
+  if (isInterfaceSharedPropertyType(prop)) {
+    return [prop.sharedPropertyType.apiName, {
+      type: "sharedPropertyBasedPropertyType",
+      sharedPropertyBasedPropertyType: {
+        requireImplementation: prop.required,
+        sharedPropertyType: convertSpt(prop.sharedPropertyType)
+      }
+    }];
+  } else {
+    return [apiName, {
+      type: "interfaceDefinedPropertyType",
+      interfaceDefinedPropertyType: {
+        apiName,
+        displayMetadata: {
+          displayName: prop.displayName ?? apiName,
+          visibility: prop.visibility ?? "NORMAL",
+          description: prop.description
+        },
+        type: prop.array ? {
+          type: "array",
+          array: {
+            subtype: propertyTypeTypeToOntologyIrInterfaceType(prop.type)
+          }
+        } : propertyTypeTypeToOntologyIrInterfaceType(prop.type),
+        constraints: {
+          primaryKeyConstraint: prop.primaryKeyConstraint ?? "NO_RESTRICTION",
+          requireImplementation: prop.required ?? true,
+          indexedForSearch: true,
+          typeClasses: prop.typeClasses ?? [],
+          dataConstraints: convertNullabilityToDataConstraint({
+            type: prop.type,
+            nullability: prop.nullability
+          }),
+          valueType: prop.valueType ? {
+            apiName: prop.valueType.apiName,
+            version: prop.valueType.version,
+            packageNamespace: prop.valueType.packageNamespace,
+            displayMetadata: prop.valueType.displayMetadata
+          } : void 0
+        }
+      }
+    }];
+  }
+}
+
 // src/conversion/toMarketplace/convertInterface.ts
 function convertInterface(interfaceType) {
   const {
@@ -997,8 +1216,7 @@ function convertInterface(interfaceType) {
     extendsInterfaces: interfaceType.extendsInterfaces.map((i) => i.apiName),
     // these are omitted from our internal types but we need to re-add them for the final json
     properties: [],
-    // TODO(mwalther): Support propertiesV3
-    propertiesV3: {}
+    propertiesV3: Object.fromEntries(Object.entries(interfaceType.propertiesV3).map(([apiName, prop]) => convertInterfaceProperty(prop, apiName)))
   };
 }
 
@@ -1211,7 +1429,8 @@ function convertObjectPropertyType(property) {
     type: property.array ? {
       type: "array",
       array: {
-        subtype: propertyTypeTypeToOntologyIrType(property.type)
+        subtype: propertyTypeTypeToOntologyIrType(property.type),
+        reducers: []
       }
     } : propertyTypeTypeToOntologyIrType(property.type),
     typeClasses: property.typeClasses ?? (shouldNotHaveRenderHints(property.type) ? [] : defaultTypeClasses),
@@ -1271,7 +1490,8 @@ function convertObject(objectType) {
     },
     datasources: [...propertyDatasources, ...derivedDatasources, objectDatasource],
     entityMetadata: {
-      arePatchesEnabled: objectType.editsEnabled ?? false
+      arePatchesEnabled: objectType.editsEnabled ?? false,
+      aliases: objectType.aliases ?? []
     }
   };
 }
@@ -1304,7 +1524,8 @@ function extractPropertyDatasource(property, objectTypeApiName) {
         mediaSetView: {
           assumedMarkings: [],
           mediaSetViewLocator: identifier,
-          properties: [property.apiName]
+          properties: [property.apiName],
+          uploadProperties: []
         }
       };
       return [buildDatasource(property.apiName, mediaSetDefinition)];
@@ -1752,6 +1973,12 @@ function convertObjectStatus(status) {
       experimental: {}
     };
   }
+  if (status === "example") {
+    return {
+      type: "example",
+      example: {}
+    };
+  }
   if (typeof status === "object" && status.type === "deprecated") {
     return {
       type: "deprecated",
@@ -2107,7 +2334,7 @@ function addNamespaceIfNone(apiName) {
 var apiNamespaceRegex = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.$/;
 var uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 async function main(args = process.argv) {
-  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.15.0-beta.6").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.15.0-beta.8").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -2285,29 +2512,39 @@ function defineAction(actionDef) {
   return fullAction;
 }
 function isPropertyParameter(def, name, type) {
-  return !Object.keys(def.nonParameterMappings ?? {}).includes(name) && !isStruct(type) && !def.excludedProperties?.includes(name);
+  if ("interfaceType" in def) {
+    return Object.keys(getFlattenedInterfaceProperties(def.interfaceType)).includes(name) && !Object.keys(def.nonParameterMappings ?? {}).includes(name) && !isStruct(type) && !def.excludedProperties?.includes(name);
+  }
+  return Object.keys(def.objectType.properties ?? {}).includes(name) && !Object.keys(def.nonParameterMappings ?? {}).includes(name) && !isStruct(type) && !def.excludedProperties?.includes(name);
 }
 function createParameters(def, propertyMap, parameterSet, requiredMap) {
   const targetParams = getTargetParameters(def, parameterSet);
-  return [...targetParams, ...Array.from(parameterSet).map((id) => ({
-    id,
-    displayName: def.parameterConfiguration?.[id]?.displayName ?? propertyMap[id]?.displayName ?? uppercaseFirstLetter(id),
-    type: def.parameterConfiguration?.[id]?.customParameterType ?? extractActionParameterType(propertyMap[id]),
-    validation: def.parameterConfiguration?.[id] !== void 0 ? {
-      ...def.parameterConfiguration?.[id],
-      allowedValues: def.parameterConfiguration?.[id].allowedValues ?? (def.parameterConfiguration?.[id].customParameterType ? extractAllowedValuesFromActionParameterType(def.parameterConfiguration?.[id].customParameterType) : extractAllowedValuesFromPropertyType(propertyMap[id]?.type)),
-      required: def.parameterConfiguration?.[id].required ?? propertyMap[id]?.nullability?.noNulls ?? false
-    } : {
-      required: propertyMap[id]?.array ?? false ? {
-        listLength: propertyMap[id]?.nullability?.noEmptyCollections ? {
-          min: 1
-        } : {}
-      } : requiredMap?.[id] ?? propertyMap[id]?.nullability?.noNulls ?? false,
-      allowedValues: extractAllowedValuesFromPropertyType(propertyMap[id]?.type)
-    },
-    defaultValue: def.parameterConfiguration?.[id]?.defaultValue,
-    description: def.parameterConfiguration?.[id]?.description
-  }))];
+  return [...targetParams, ...Array.from(parameterSet).map((id) => {
+    let propertyMetadata = void 0;
+    if (id in propertyMap) {
+      propertyMetadata = "sharedPropertyType" in propertyMap[id] ? propertyMap[id].sharedPropertyType : propertyMap[id];
+    }
+    return {
+      id,
+      displayName: def.parameterConfiguration?.[id]?.displayName ?? propertyMetadata?.displayName ?? uppercaseFirstLetter(id),
+      type: def.parameterConfiguration?.[id]?.customParameterType ?? extractActionParameterType(propertyMetadata),
+      validation: def.parameterConfiguration?.[id] !== void 0 ? {
+        ...def.parameterConfiguration?.[id],
+        allowedValues: def.parameterConfiguration?.[id].allowedValues ?? (def.parameterConfiguration?.[id].customParameterType ? extractAllowedValuesFromActionParameterType(def.parameterConfiguration?.[id].customParameterType) : extractAllowedValuesFromPropertyType(propertyMetadata.type)),
+        required: def.parameterConfiguration?.[id].required ?? propertyMetadata?.nullability?.noNulls ?? false
+      } : {
+        required: propertyMetadata.array ?? false ? {
+          listLength: propertyMetadata.nullability?.noEmptyCollections ? {
+            min: 1
+          } : {}
+        } : requiredMap?.[id] ?? propertyMetadata?.nullability?.noNulls ?? false,
+        allowedValues: extractAllowedValuesFromPropertyType(propertyMetadata?.type)
+      },
+      defaultValue: def.parameterConfiguration?.[id]?.defaultValue,
+      description: def.parameterConfiguration?.[id]?.description,
+      renderHint: def.parameterConfiguration?.[id]?.renderHint
+    };
+  })];
 }
 function getTargetParameters(def, parameterSet) {
   const targetParams = [];
@@ -2861,7 +3098,7 @@ function validateActionParameters(def, properties, name) {
     !(properties.includes(id) || properties.includes(addNamespaceIfNone(id)) || def.parameterConfiguration?.[id].customParameterType !== void 0 || isTargetParameter(id)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Parameter ${id} does not exist as a property on ${name} and its type is not explicitly defined`) : invariant7__default.default(false) : void 0;
   });
   [...Object.keys(def.nonParameterMappings ?? {}), ...def.excludedProperties ?? []].forEach((id) => {
-    !(properties.includes(id) || properties.includes(addNamespaceIfNone(id))) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property ${id} does not exist as a property on ${name}`) : invariant7__default.default(false) : void 0;
+    !(properties.includes(id) || properties.includes(addNamespaceIfNone(id)) || properties.includes(withoutNamespace(id))) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property ${id} does not exist as a property on ${name}`) : invariant7__default.default(false) : void 0;
   });
 }
 function createDefaultParameterOrdering(def, properties, parameters, priorityId) {
@@ -2876,15 +3113,6 @@ function validateParameterOrdering(parameterOrdering, parameterSet, actionApiNam
 function isTargetParameter(parameterId) {
   return parameterId === MODIFY_OBJECT_PARAMETER || parameterId === CREATE_OR_MODIFY_OBJECT_PARAMETER || parameterId === CREATE_INTERFACE_OBJECT_PARAMETER || parameterId === MODIFY_INTERFACE_OBJECT_PARAMETER;
 }
-function addNamespaceToActionDefinition(def) {
-  def.parameterConfiguration = Object.fromEntries(Object.entries(def.parameterConfiguration ?? {}).map(([id, config]) => [getInterfaceParameterName(def, id), config]));
-  def.nonParameterMappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [addNamespaceIfNone(id), value]));
-  def.excludedProperties = (def.excludedProperties ?? []).map((id) => addNamespaceIfNone(id));
-  def.sections = def.sections?.map((section) => ({
-    ...section,
-    parameters: section.parameters.map((p) => getInterfaceParameterName(def, p))
-  }));
-}
 function getInterfaceParameterName(def, parameter) {
   if (def.useNonNamespacedParameters) {
     return getNonNamespacedParameterName(def, parameter);
@@ -2894,6 +3122,41 @@ function getInterfaceParameterName(def, parameter) {
 function getNonNamespacedParameterName(def, parameter) {
   return def.conflictingParameterOverrides?.[parameter] ?? (parameter.split(".").pop() || parameter);
 }
+function convertInterfacePropertyMappingValue(value) {
+  switch (value.type) {
+    case "uuid":
+      return {
+        type: "logicRuleValue",
+        logicRuleValue: {
+          type: "uniqueIdentifier",
+          uniqueIdentifier: {
+            linkId: value.linkId ?? crypto.randomUUID()
+          }
+        }
+      };
+    case "currentTime":
+      return {
+        type: "logicRuleValue",
+        logicRuleValue: {
+          type: "currentTime",
+          currentTime: {}
+        }
+      };
+    case "currentUser":
+      return {
+        type: "logicRuleValue",
+        logicRuleValue: {
+          type: "currentUser",
+          currentUser: {}
+        }
+      };
+    default:
+      return {
+        type: "logicRuleValue",
+        logicRuleValue: value
+      };
+  }
+}
 function convertMappingValue(value) {
   switch (value.type) {
     case "uuid":
@@ -2920,12 +3183,12 @@ function convertMappingValue(value) {
 
 // src/api/defineCreateInterfaceObjectAction.ts
 function defineCreateInterfaceObjectAction(def) {
-  addNamespaceToActionDefinition(def);
   const allProperties = getFlattenedInterfaceProperties(def.interfaceType);
   validateActionParameters(def, Object.keys(allProperties), def.interfaceType.apiName);
-  const sptNames = Object.keys(allProperties).filter((apiName) => isPropertyParameter(def, apiName, allProperties[apiName].sharedPropertyType.type));
-  const parameterNames = new Set(sptNames.map((apiName) => getInterfaceParameterName(def, apiName)));
-  const propertyMap = Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [getInterfaceParameterName(def, id), prop.sharedPropertyType]));
+  const actionInterfaceProperties = Object.entries(allProperties).filter(([apiName, type]) => isPropertyParameter(def, apiName, getInterfacePropertyTypeType(type)));
+  const sptNames = actionInterfaceProperties.filter(([_apiName, type]) => isInterfaceSharedPropertyType(type)).map(([apiName]) => apiName);
+  const parameterNames = new Set(actionInterfaceProperties.map(([apiName, _type]) => getInterfaceParameterName(def, apiName)));
+  const propertyMap = Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [getInterfaceParameterName(def, id), prop]));
   Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(getInterfaceParameterName(def, param)));
   parameterNames.add(CREATE_INTERFACE_OBJECT_PARAMETER);
   const actionApiName = def.apiName ?? `create-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`;
@@ -2935,8 +3198,17 @@ function defineCreateInterfaceObjectAction(def) {
     }
     validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
   }
-  const parameters = createParameters(def, propertyMap, parameterNames, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.required])));
-  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  const parameters = createParameters(def, propertyMap, parameterNames, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.required ?? true])));
+  let sptMappings = {};
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => {
+    if (sptNames.includes(id)) {
+      sptMappings = {
+        ...sptMappings,
+        [id]: convertMappingValue(value)
+      };
+    }
+    return [id, convertInterfacePropertyMappingValue(value)];
+  }));
   return defineAction({
     apiName: actionApiName,
     displayName: def.displayName ?? `Create ${def.interfaceType.displayMetadata.displayName}`,
@@ -2958,6 +3230,16 @@ function defineCreateInterfaceObjectAction(def) {
             type: "parameterId",
             parameterId: def.useNonNamespacedParameters ? getNonNamespacedParameterName(def, id) : id
           }])),
+          ...sptMappings
+        },
+        interfacePropertyValues: {
+          ...Object.fromEntries(actionInterfaceProperties.map(([id, _type]) => [id, {
+            type: "logicRuleValue",
+            logicRuleValue: {
+              type: "parameterId",
+              parameterId: def.useNonNamespacedParameters ? getNonNamespacedParameterName(def, id) : id
+            }
+          }])),
           ...mappings
         }
       }
@@ -3201,22 +3483,6 @@ function defineDeleteObjectAction(def) {
     }
   });
 }
-function defineSharedPropertyType(sptDef) {
-  const apiName = namespace + sptDef.apiName;
-  !(ontologyDefinition[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Shared property type ${apiName} already exists`) : invariant7__default.default(false) : void 0;
-  !(!shouldNotHaveRenderHints(sptDef.type) || !hasRenderHints(sptDef.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Shared property type ${apiName} of type '${getPropertyTypeName(sptDef.type)}' should not have render hints`) : invariant7__default.default(false) : void 0;
-  const fullSpt = {
-    ...sptDef,
-    apiName,
-    nonNameSpacedApiName: sptDef.apiName,
-    displayName: sptDef.displayName ?? sptDef.apiName,
-    // This way the non-namespaced api name is the display name (maybe not ideal)
-    typeClasses: sptDef.typeClasses ?? (shouldNotHaveRenderHints(sptDef.type) ? [] : defaultTypeClasses),
-    __type: OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE
-  };
-  updateOntology(fullSpt);
-  return fullSpt;
-}
 
 // src/api/interface/mapSimplifiedStatusToInterfaceTypeStatus.ts
 function mapSimplifiedStatusToInterfaceTypeStatus(status) {
@@ -3240,6 +3506,11 @@ function mapSimplifiedStatusToInterfaceTypeStatus(status) {
         type: "experimental",
         experimental: {}
       };
+    case "example":
+      return {
+        type: "example",
+        example: {}
+      };
     default:
       throw new Error(`Invalid status type: ${status.type}`);
   }
@@ -3254,19 +3525,33 @@ function combineApiNamespaceIfMissing(namespace2, apiName) {
 function defineInterface(interfaceDef) {
   const apiName = namespace + interfaceDef.apiName;
   !(ontologyDefinition[OntologyEntityTypeEnum.INTERFACE_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Interface ${apiName} already exists`) : invariant7__default.default(false) : void 0;
-  const properties = Object.fromEntries(Object.entries(interfaceDef.properties ?? {}).map(([unNamespacedPropApiName, type]) => {
-    if (typeof type === "object" && "propertyDefinition" in type) {
-      const apiName3 = combineApiNamespaceIfMissing(namespace, typeof type.propertyDefinition === "object" && "apiName" in type.propertyDefinition ? type.propertyDefinition.apiName : unNamespacedPropApiName);
-      return [apiName3, {
-        required: type.required,
-        sharedPropertyType: unifyBasePropertyDefinition(namespace, unNamespacedPropApiName, type.propertyDefinition)
+  const spts = Object.fromEntries(Object.entries(interfaceDef.properties ?? {}).filter(([_name, prop]) => {
+    return isInterfaceSharedPropertyType(prop) || "apiName" in prop;
+  }).map(([s, spt]) => {
+    const required = isInterfaceSharedPropertyType(spt) ? spt.required : true;
+    return [s, {
+      sharedPropertyType: isInterfaceSharedPropertyType(spt) ? spt.sharedPropertyType : spt,
+      required
+    }];
+  }));
+  const propertiesV2 = Object.fromEntries(Object.entries(spts).map(([propName, type]) => {
+    const sptApiName = combineApiNamespaceIfMissing(namespace, type.sharedPropertyType.apiName);
+    return [sptApiName, {
+      required: type.required,
+      sharedPropertyType: verifyBasePropertyDefinition(namespace, propName, type.sharedPropertyType)
+    }];
+  }));
+  const propertiesV3 = Object.fromEntries(Object.entries(interfaceDef.properties ?? {}).map(([apiName2, prop]) => {
+    const required = typeof prop === "object" && isInterfaceSharedPropertyType(prop) ? prop.required : true;
+    const propertyBase = typeof prop === "object" && isInterfaceSharedPropertyType(prop) ? prop.sharedPropertyType : prop;
+    if (typeof propertyBase === "object" && "nonNameSpacedApiName" in propertyBase) {
+      return [apiName2, {
+        required,
+        sharedPropertyType: propertyBase
       }];
+    } else {
+      return [apiName2, propertyBase];
     }
-    const apiName2 = combineApiNamespaceIfMissing(namespace, typeof type === "object" && "apiName" in type ? type.apiName : unNamespacedPropApiName);
-    return [apiName2, {
-      required: true,
-      sharedPropertyType: unifyBasePropertyDefinition(namespace, unNamespacedPropApiName, type)
-    }];
   }));
   const extendsInterfaces = interfaceDef.extends ? Array.isArray(interfaceDef.extends) ? interfaceDef.extends : [interfaceDef.extends] : [];
   const status = mapSimplifiedStatusToInterfaceTypeStatus(interfaceDef.status ?? {
@@ -3289,31 +3574,22 @@ function defineInterface(interfaceDef) {
     extendsInterfaces,
     links: [],
     status,
-    propertiesV2: properties,
+    propertiesV2,
+    propertiesV3,
     searchable: interfaceDef.searchable ?? true,
     __type: OntologyEntityTypeEnum.INTERFACE_TYPE
   };
   updateOntology(fullInterface);
   return fullInterface;
 }
-function unifyBasePropertyDefinition(namespace2, apiName, type) {
-  if (typeof type === "string" || typeof type === "object" && !("apiName" in type)) {
-    !isPropertyTypeType(type) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Invalid data type ${JSON.stringify(type)} for property ${apiName} on InterfaceType ${apiName}`) : invariant7__default.default(false) : void 0;
-    const spt = defineSharedPropertyType({
-      apiName,
-      displayName: apiName,
-      type,
-      array: false
-    });
-    return spt;
-  } else {
-    const unNamespacedTypeApiName = withoutNamespace(type.apiName);
-    !(namespace2 + apiName === type.apiName || apiName === unNamespacedTypeApiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `property key and it's apiName must be identical. ${JSON.stringify({
-      key: apiName,
-      apiName: type.apiName
-    })}`) : invariant7__default.default(false) : void 0;
-    return type;
-  }
+function verifyBasePropertyDefinition(namespace2, apiName, type) {
+  const unNamespacedTypeApiName = withoutNamespace(type.apiName);
+  !(isPropertyTypeType(type.type) || isExotic(type.type)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Invalid data type ${JSON.stringify(type)} for property ${apiName} on InterfaceType ${apiName}`) : invariant7__default.default(false) : void 0;
+  !(namespace2 + apiName === type.apiName || apiName === unNamespacedTypeApiName) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `property key and it's apiName must be identical. ${JSON.stringify({
+    key: apiName,
+    apiName: type.apiName
+  })}`) : invariant7__default.default(false) : void 0;
+  return type;
 }
 function defineInterfaceLinkConstraint(linkDef) {
   const fromLinkMeta = getLinkMeta(linkDef);
@@ -3410,12 +3686,14 @@ function convertLinkTypeMetadata(metadata) {
 
 // src/api/defineModifyInterfaceObjectAction.ts
 function defineModifyInterfaceObjectAction(def) {
-  addNamespaceToActionDefinition(def);
   const allProperties = getFlattenedInterfaceProperties(def.interfaceType);
   validateActionParameters(def, Object.keys(allProperties), def.interfaceType.apiName);
-  const sptNames = Object.keys(allProperties).filter((apiName) => isPropertyParameter(def, apiName, allProperties[apiName].sharedPropertyType.type));
-  const parameterNames = new Set(sptNames.map((apiName) => getInterfaceParameterName(def, apiName)));
-  const propertyMap = Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [getInterfaceParameterName(def, id), prop.sharedPropertyType]));
+  const actionInterfaceProperties = Object.entries(allProperties).filter(([apiName, type]) => {
+    return isPropertyParameter(def, apiName, getInterfacePropertyTypeType(type));
+  });
+  const sptNames = actionInterfaceProperties.filter(([_apiName, type]) => isInterfaceSharedPropertyType(type)).map(([apiName]) => apiName);
+  const parameterNames = new Set(actionInterfaceProperties.map(([apiName, _type]) => getInterfaceParameterName(def, apiName)));
+  const propertyMap = Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [getInterfaceParameterName(def, id), prop]));
   Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(getInterfaceParameterName(def, param)));
   parameterNames.add(MODIFY_INTERFACE_OBJECT_PARAMETER);
   const actionApiName = def.apiName ?? `modify-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`;
@@ -3425,8 +3703,17 @@ function defineModifyInterfaceObjectAction(def) {
     }
     validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
   }
-  const parameters = createParameters(def, propertyMap, parameterNames, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.required])));
-  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  const parameters = createParameters(def, propertyMap, parameterNames, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.required ?? true])));
+  let sptMappings = {};
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => {
+    if (sptNames.includes(id)) {
+      sptMappings = {
+        ...sptMappings,
+        [id]: convertMappingValue(value)
+      };
+    }
+    return [id, convertInterfacePropertyMappingValue(value)];
+  }));
   return defineAction({
     apiName: actionApiName,
     displayName: def.displayName ?? `Modify ${def.interfaceType.displayMetadata.displayName}`,
@@ -3441,12 +3728,23 @@ function defineModifyInterfaceObjectAction(def) {
     rules: [{
       type: "modifyInterfaceRule",
       modifyInterfaceRule: {
+        interfaceApiName: def.interfaceType.apiName,
         interfaceObjectToModifyParameter: "interfaceObjectToModifyParameter",
         sharedPropertyValues: {
           ...Object.fromEntries(sptNames.map((id) => [id, {
             type: "parameterId",
             parameterId: def.useNonNamespacedParameters ? getNonNamespacedParameterName(def, id) : id
           }])),
+          ...sptMappings
+        },
+        interfacePropertyValues: {
+          ...Object.fromEntries(actionInterfaceProperties.map(([id, _type]) => [id, {
+            type: "logicRuleValue",
+            logicRuleValue: {
+              type: "parameterId",
+              parameterId: def.useNonNamespacedParameters ? getNonNamespacedParameterName(def, id) : id
+            }
+          }])),
           ...mappings
         }
       }
@@ -3556,6 +3854,22 @@ function defineModifyObjectAction(def) {
     }
   });
 }
+function defineSharedPropertyType(sptDef) {
+  const apiName = namespace + sptDef.apiName;
+  !(ontologyDefinition[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Shared property type ${apiName} already exists`) : invariant7__default.default(false) : void 0;
+  !(!shouldNotHaveRenderHints(sptDef.type) || !hasRenderHints(sptDef.typeClasses)) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Shared property type ${apiName} of type '${getPropertyTypeName(sptDef.type)}' should not have render hints`) : invariant7__default.default(false) : void 0;
+  const fullSpt = {
+    ...sptDef,
+    apiName,
+    nonNameSpacedApiName: sptDef.apiName,
+    displayName: sptDef.displayName ?? sptDef.apiName,
+    // This way the non-namespaced api name is the display name (maybe not ideal)
+    typeClasses: sptDef.typeClasses ?? (shouldNotHaveRenderHints(sptDef.type) ? [] : defaultTypeClasses),
+    __type: OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE
+  };
+  updateOntology(fullSpt);
+  return fullSpt;
+}
 function convertValueTypeTypeToBaseType(valueType) {
   switch (true) {
     case (typeof valueType === "object" && valueType.type === "array"):
@@ -3630,10 +3944,7 @@ function defineValueType(valueTypeDef) {
       displayName,
       description: description ?? ""
     },
-    status: {
-      type: "active",
-      active: {}
-    },
+    status: convertUserValueTypeStatusToValueTypeStatus(valueTypeDef.status),
     version,
     baseType,
     constraints,
@@ -3643,6 +3954,22 @@ function defineValueType(valueTypeDef) {
   updateOntology(vt);
   return vt;
 }
+function convertUserValueTypeStatusToValueTypeStatus(status) {
+  if (typeof status === "object" && status.type === "deprecated") {
+    return {
+      type: "deprecated",
+      deprecated: {
+        message: status.message,
+        deadline: status.deadline,
+        replacedBy: status.replacedBy
+      }
+    };
+  }
+  return {
+    type: "active",
+    active: {}
+  };
+}
 
 // src/api/importOntologyEntity.ts
 function importOntologyEntity(e) {