@osdk/maker 0.15.0-beta.5 → 0.15.0-beta.7

package/build/cjs/index.cjs

@@ -256,13 +256,26 @@ function getObject(object) {
   };
 }
 
+// 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 +292,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 +341,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 +375,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 +383,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 {
@@ -405,16 +420,38 @@ function validateDerivedDatasource(objectDef, datasource) {
   });
   const isLinkedProperties = typeof Object.values(datasource.propertyMapping)[0] === "string";
   if (isLinkedProperties) {
-    validateLinkedProperties(datasource);
+    validateLinkedProperties(datasource, objectDef);
   } else {
     validateAggregations(datasource, objectDef);
   }
 }
+function getPropertiesForValidation(linkObject, objectDef) {
+  const targetApiName = typeof linkObject === "string" ? linkObject : linkObject.apiName;
+  const selfApiName = namespace + objectDef.apiName;
+  if (targetApiName === selfApiName) {
+    return {
+      apiName: selfApiName,
+      hasProperty: (propName) => objectDef.properties?.[propName] !== void 0
+    };
+  }
+  const {
+    apiName,
+    object
+  } = getObject(linkObject);
+  return {
+    apiName,
+    hasProperty: (propName) => object.properties?.find((p) => p.apiName === propName) !== void 0
+  };
+}
 function validateLinkedProperties(datasource, objectDef) {
   const foreignProperties = Object.values(datasource.propertyMapping);
-  const finalObject = getObject(datasource.linkDefinition.at(-1).linkType.toMany.object).object;
+  const targetObject = datasource.linkDefinition.at(-1).linkType.toMany.object;
+  const {
+    apiName,
+    hasProperty
+  } = getPropertiesForValidation(targetObject, objectDef);
   foreignProperties.forEach((prop) => {
-    !(finalObject.properties?.find((p) => p.apiName === prop) !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${prop}' on object '${finalObject.apiName}' is not defined`) : invariant7__default.default(false) : void 0;
+    !hasProperty(prop) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${prop}' on object '${apiName}' is not defined`) : invariant7__default.default(false) : void 0;
   });
 }
 function validateAggregations(datasource, objectDef) {
@@ -440,8 +477,12 @@ function validateAggregations(datasource, objectDef) {
     }
     if (agg.type !== "count") {
       const foreignProperty = agg.property;
-      const finalObject = getObject(datasource.linkDefinition.at(-1).linkType.toMany.object).object;
-      !(finalObject.properties?.find((p) => p.apiName === foreignProperty) !== void 0) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${foreignProperty}' on object '${finalObject.apiName}' is not defined`) : invariant7__default.default(false) : void 0;
+      const targetObject = datasource.linkDefinition.at(-1).linkType.toMany.object;
+      const {
+        apiName,
+        hasProperty
+      } = getPropertiesForValidation(targetObject, objectDef);
+      !hasProperty(foreignProperty) ? process.env.NODE_ENV !== "production" ? invariant7__default.default(false, `Property '${foreignProperty}' on object '${apiName}' is not defined`) : invariant7__default.default(false) : void 0;
     }
   });
 }
@@ -693,7 +734,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
@@ -813,6 +854,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 ?? []
             };
@@ -909,6 +954,7 @@ function convertSpt({
   visibility,
   gothamMapping,
   typeClasses,
+  aliases,
   valueType,
   nullability,
   baseFormatter
@@ -927,10 +973,11 @@ function convertSpt({
     type: array ? {
       type: "array",
       array: {
-        subtype: propertyTypeTypeToOntologyIrType(type)
+        subtype: propertyTypeTypeToOntologyIrType(type),
+        reducers: []
       }
     } : propertyTypeTypeToOntologyIrType(type),
-    aliases: [],
+    aliases: aliases ?? [],
     baseFormatter,
     dataConstraints: dataConstraint,
     gothamMapping,
@@ -945,6 +992,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 {
@@ -971,8 +1190,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)))
   };
 }
 
@@ -1185,7 +1403,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),
@@ -1245,7 +1464,8 @@ function convertObject(objectType) {
     },
     datasources: [...propertyDatasources, ...derivedDatasources, objectDatasource],
     entityMetadata: {
-      arePatchesEnabled: objectType.editsEnabled ?? false
+      arePatchesEnabled: objectType.editsEnabled ?? false,
+      aliases: objectType.aliases ?? []
     }
   };
 }
@@ -1278,7 +1498,8 @@ function extractPropertyDatasource(property, objectTypeApiName) {
         mediaSetView: {
           assumedMarkings: [],
           mediaSetViewLocator: identifier,
-          properties: [property.apiName]
+          properties: [property.apiName],
+          uploadProperties: []
         }
       };
       return [buildDatasource(property.apiName, mediaSetDefinition)];
@@ -2081,7 +2302,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.5").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.7").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -2259,29 +2480,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 = [];
@@ -2835,7 +3066,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) {
@@ -2850,15 +3081,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);
@@ -2868,6 +3090,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":
@@ -2894,12 +3151,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)}`}`;
@@ -2909,8 +3166,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}`,
@@ -2932,6 +3198,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
         }
       }
@@ -3175,22 +3451,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) {
@@ -3228,19 +3488,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 ?? {
@@ -3263,31 +3537,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);
@@ -3384,12 +3649,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)}`}`;
@@ -3399,8 +3666,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}`,
@@ -3415,12 +3691,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
         }
       }
@@ -3530,6 +3817,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"):