@osdk/maker 0.12.0-beta.9 → 0.12.0

package/build/cjs/index.cjs

@@ -3,15 +3,14 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var consola = require('consola');
-var jiti = require('jiti');
 var fs2 = require('fs/promises');
 var path2 = require('path');
 var invariant5 = require('tiny-invariant');
 var yargs = require('yargs');
 var helpers = require('yargs/helpers');
 var fs = require('fs');
+var crypto = require('crypto');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 function _interopNamespace(e) {
@@ -50,6 +49,8 @@ var OntologyEntityTypeEnum = /* @__PURE__ */ function(OntologyEntityTypeEnum2) {
   OntologyEntityTypeEnum2["VALUE_TYPE"] = "VALUE_TYPE";
   return OntologyEntityTypeEnum2;
 }({});
+var MODIFY_OBJECT_PARAMETER = "objectToModifyParameter";
+var CREATE_OR_MODIFY_OBJECT_PARAMETER = "objectToCreateOrModifyParameter";
 
 // src/api/defineObject.ts
 var ISO_8601_DURATION = /^P(?!$)(?:(?:((?:\d+Y)|(?:\d+(?:\.|,)\d+Y$))?((?:\d+M)|(?:\d+(?:\.|,)\d+M$))?((?:\d+D)|(?:\d+(?:\.|,)\d+D$))?(T((?:\d+H)|(?:\d+(?:\.|,)\d+H$))?((?:\d+M)|(?:\d+(?:\.|,)\d+M$))?((?:\d+S)|(?:\d+(?:\.|,)\d+S$))?)?)|(?:\d+(?:(?:\.|,)\d+)?W))$/;
@@ -170,8 +171,6 @@ function convertUserObjectPropertyType(apiName, property) {
     type: property.type
   };
 }
-
-// src/api/ontologyUtils.ts
 function convertActionVisibility(visibility) {
   switch (visibility) {
     case "editable":
@@ -241,6 +240,22 @@ function convertActionParameterConditionalOverride(override, validation) {
         }
       };
       break;
+    case "defaultValue":
+      parameterBlockOverride = {
+        type: "prefill",
+        prefill: {
+          prefill: override.defaultValue
+        }
+      };
+      break;
+    case "constraint":
+      parameterBlockOverride = {
+        type: "allowedValues",
+        allowedValues: {
+          allowedValues: extractAllowedValues(override.constraint)
+        }
+      };
+      break;
     default:
       throw new Error(`Unknown parameter override type`);
   }
@@ -249,6 +264,23 @@ function convertActionParameterConditionalOverride(override, validation) {
     parameterBlockOverrides: [parameterBlockOverride]
   };
 }
+function convertSectionConditionalOverride(override, defaultVisibility) {
+  return {
+    condition: convertConditionDefinition(override.condition),
+    sectionBlockOverrides: [{
+      type: "visibility",
+      visibility: {
+        visibility: defaultVisibility === "visible" ? {
+          type: "hidden",
+          hidden: {}
+        } : {
+          type: "visible",
+          visible: {}
+        }
+      }
+    }]
+  };
+}
 function convertConditionDefinition(condition) {
   switch (condition.type) {
     case "and":
@@ -318,6 +350,51 @@ function convertConditionDefinition(condition) {
       return condition;
   }
 }
+function getFormContentOrdering(action, parameterOrdering) {
+  if (!action.sections) return [];
+  const parametersToSection = Object.fromEntries(Object.entries(action.sections).flatMap(([sectionId, section]) => section.parameters.map((param) => [param, sectionId])));
+  const seenIds = /* @__PURE__ */ new Set();
+  const formContentOrdering = [];
+  parameterOrdering.forEach((param) => {
+    if (param in parametersToSection && !seenIds.has(parametersToSection[param])) {
+      formContentOrdering.push({
+        type: "sectionId",
+        sectionId: parametersToSection[param]
+      });
+      seenIds.add(parametersToSection[param]);
+    } else if (!(param in parametersToSection)) {
+      formContentOrdering.push({
+        type: "parameterId",
+        parameterId: param
+      });
+      seenIds.add(param);
+    }
+  });
+  return formContentOrdering;
+}
+function convertMappingValue(value) {
+  switch (value.type) {
+    case "uuid":
+      return {
+        type: "uniqueIdentifier",
+        uniqueIdentifier: {
+          linkId: value.linkId ?? crypto.randomUUID()
+        }
+      };
+    case "currentTime":
+      return {
+        type: "currentTime",
+        currentTime: {}
+      };
+    case "currentUser":
+      return {
+        type: "currentUser",
+        currentUser: {}
+      };
+    default:
+      return value;
+  }
+}
 var defaultTypeClasses = [{
   kind: "render_hint",
   name: "SELECTABLE"
@@ -704,7 +781,11 @@ function convertToWireImportedTypes(importedTypes2) {
       apiName: spt.sharedPropertyType.apiName,
       displayName: spt.sharedPropertyType.displayMetadata.displayName,
       description: spt.sharedPropertyType.displayMetadata.description,
-      type: spt.sharedPropertyType.type
+      type: spt.sharedPropertyType.type,
+      valueType: spt.sharedPropertyType.valueType === void 0 ? void 0 : {
+        apiName: spt.sharedPropertyType.valueType.apiName,
+        version: spt.sharedPropertyType.valueType.version
+      }
     })),
     objectTypes: Object.values(asBlockData.objectTypes).map((ot) => ({
       apiName: ot.objectType.apiName,
@@ -1090,7 +1171,7 @@ function convertLink(linkType) {
               apiName: linkType.toMany.object.primaryKeyPropertyApiName,
               object: linkType.toMany.object.apiName
             },
-            column: linkType.many.object.primaryKeyPropertyApiName
+            column: linkType.toMany.object.primaryKeyPropertyApiName
           }]
         }
       },
@@ -1143,6 +1224,9 @@ function convertInterface(interfaceType) {
     properties: []
   };
 }
+function dumpOntologyFullMetadata() {
+  return convertToWireOntologyIr(ontologyDefinition);
+}
 function convertSpt({
   type,
   array,
@@ -1178,7 +1262,10 @@ function convertSpt({
     gothamMapping,
     indexedForSearch: true,
     typeClasses: typeClasses ?? [],
-    valueType
+    valueType: valueType === void 0 ? void 0 : {
+      apiName: valueType.apiName,
+      version: valueType.version
+    }
   };
 }
 function convertObjectStatus(status) {
@@ -1216,6 +1303,7 @@ function convertAction(action) {
   const actionValidation = convertActionValidation(action);
   const actionParameters = convertActionParameters(action);
   const actionSections = convertActionSections(action);
+  const parameterOrdering = action.parameterOrdering ?? (action.parameters ?? []).map((p) => p.id);
   return {
     actionType: {
       actionTypeLogic: {
@@ -1228,8 +1316,8 @@ function convertAction(action) {
         apiName: action.apiName,
         displayMetadata: {
           configuration: {
-            defaultLayout: "FORM",
-            displayAndFormat: {
+            defaultLayout: action.defaultFormat ?? "FORM",
+            displayAndFormat: action.displayAndFormat ?? {
               table: {
                 columnWidthByParameterRid: {},
                 enableFileImport: true,
@@ -1238,7 +1326,7 @@ function convertAction(action) {
                 rowHeightInLines: 1
               }
             },
-            enableLayoutUserSwitch: false
+            enableLayoutUserSwitch: action.enableLayoutSwitch ?? false
           },
           description: action.description ?? "",
           displayName: action.displayName,
@@ -1249,11 +1337,20 @@ function convertAction(action) {
               color: "#000000"
             }
           },
-          successMessage: [],
-          typeClasses: action.typeClasses ?? []
+          successMessage: action.submissionMetadata?.successMessage ? [{
+            type: "message",
+            message: action.submissionMetadata.successMessage
+          }] : [],
+          typeClasses: action.typeClasses ?? [],
+          ...action.submissionMetadata?.submitButtonDisplayMetadata && {
+            submitButtonDisplayMetadata: action.submissionMetadata.submitButtonDisplayMetadata
+          },
+          ...action.submissionMetadata?.undoButtonConfiguration && {
+            undoButtonConfiguration: action.submissionMetadata.undoButtonConfiguration
+          }
         },
-        formContentOrdering: action.formContentOrdering ?? [],
-        parameterOrdering: (action.parameters ?? []).map((p) => p.id),
+        parameterOrdering,
+        formContentOrdering: getFormContentOrdering(action, parameterOrdering),
         parameters: actionParameters,
         sections: actionSections,
         status: typeof action.status === "string" ? {
@@ -1284,16 +1381,35 @@ function convertActionValidation(action) {
         defaultValidation: {
           display: {
             renderHint: renderHintFromBaseType(p),
-            visibility: convertActionVisibility(p.validation.defaultVisibility)
+            visibility: convertActionVisibility(p.validation.defaultVisibility),
+            ...p.defaultValue && {
+              prefill: p.defaultValue
+            }
           },
           validation: {
-            allowedValues: extractAllowedValues(p),
+            allowedValues: extractAllowedValues(p.validation.allowedValues),
             required: convertParameterRequirementConstraint(p.validation.required)
           }
         },
         conditionalOverrides: p.validation.conditionalOverrides?.map((override) => convertActionParameterConditionalOverride(override, p.validation)) ?? []
       }];
-    }))
+    })),
+    sectionValidations: {
+      ...Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [section.id, {
+        defaultDisplayMetadata: section.defaultVisibility === "hidden" ? {
+          visibility: {
+            type: "hidden",
+            hidden: {}
+          }
+        } : {
+          visibility: {
+            type: "visible",
+            visible: {}
+          }
+        },
+        conditionalOverrides: section.conditionalOverrides?.map((override) => convertSectionConditionalOverride(override, section.defaultVisibility ?? "visible")) ?? []
+      }]))
+    }
   };
 }
 function convertActionParameters(action) {
@@ -1311,32 +1427,41 @@ function convertActionParameters(action) {
   }]));
 }
 function convertActionSections(action) {
-  return Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, parameterIds]) => [sectionId, {
+  return Object.fromEntries(Object.entries(action.sections ?? {}).map(([sectionId, section]) => [sectionId, {
     id: sectionId,
-    content: parameterIds.map((p) => ({
+    content: section.parameters.map((p) => ({
       type: "parameterId",
       parameterId: p
     })),
     displayMetadata: {
-      collapsedByDefault: false,
-      columnCount: 1,
-      description: "",
-      displayName: sectionId,
-      showTitleBar: true
+      collapsedByDefault: section.collapsedByDefault ?? false,
+      columnCount: section.columnCount ?? 1,
+      description: section.description ?? "",
+      displayName: section.displayName ?? convertToDisplayName(sectionId),
+      showTitleBar: section.showTitleBar ?? true,
+      ...section.style && {
+        style: section.style === "box" ? {
+          type: "box",
+          box: {}
+        } : {
+          type: "minimal",
+          minimal: {}
+        }
+      }
     }
   }]));
 }
-function extractAllowedValues(parameter) {
-  switch (parameter.validation.allowedValues.type) {
+function extractAllowedValues(allowedValues) {
+  switch (allowedValues.type) {
     case "oneOf":
       return {
         type: "oneOf",
         oneOf: {
           type: "oneOf",
           oneOf: {
-            labelledValues: parameter.validation.allowedValues.oneOf,
+            labelledValues: allowedValues.oneOf,
             otherValueAllowed: {
-              allowed: false
+              allowed: allowedValues.otherValueAllowed ?? false
             }
           }
         }
@@ -1345,7 +1470,7 @@ function extractAllowedValues(parameter) {
       const {
         min,
         max
-      } = parameter.validation.allowedValues;
+      } = allowedValues;
       return {
         type: "range",
         range: {
@@ -1371,17 +1496,17 @@ function extractAllowedValues(parameter) {
         minLength,
         maxLength,
         regex
-      } = parameter.validation.allowedValues;
+      } = allowedValues;
       return {
         type: "text",
         text: {
           type: "text",
           text: {
             ...minLength === void 0 ? {} : {
-              minimumLength: minLength
+              minLength
             },
             ...maxLength === void 0 ? {} : {
-              maximumLength: maxLength
+              maxLength
             },
             ...regex === void 0 ? {} : {
               regex: {
@@ -1396,7 +1521,7 @@ function extractAllowedValues(parameter) {
       const {
         minimum,
         maximum
-      } = parameter.validation.allowedValues;
+      } = allowedValues;
       return {
         type: "datetime",
         datetime: {
@@ -1413,7 +1538,7 @@ function extractAllowedValues(parameter) {
         objectTypeReference: {
           type: "objectTypeReference",
           objectTypeReference: {
-            interfaceTypeRids: parameter.validation.allowedValues.interfaceTypes
+            interfaceTypeRids: allowedValues.interfaceTypes
           }
         }
       };
@@ -1431,7 +1556,7 @@ function extractAllowedValues(parameter) {
         }
       };
     default:
-      const k = parameter.validation.allowedValues.type;
+      const k = allowedValues.type;
       return {
         type: k,
         [k]: {
@@ -1596,7 +1721,7 @@ function convertCardinality(cardinality) {
 // src/cli/main.ts
 var apiNamespaceRegex = /^[a-z0-9-]+(\.[a-z0-9-]+)*\.$/;
 async function main(args = process.argv) {
-  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.12.0-beta.9").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.12.0").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -1656,14 +1781,7 @@ async function main(args = process.argv) {
   }
 }
 async function loadOntology(input, apiNamespace, outputDir, dependencyFile) {
-  const q = await defineOntology(apiNamespace, async () => {
-    const jiti$1 = jiti.createJiti(undefined, {
-      moduleCache: true,
-      debug: false,
-      importMeta: ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)) })
-    });
-    const module = await jiti$1.import(input);
-  }, outputDir, dependencyFile);
+  const q = await defineOntology(apiNamespace, async () => await import(input), outputDir, dependencyFile);
   return q;
 }
 var MAX_SEARCH_DEPTH = 5;
@@ -1730,7 +1848,7 @@ function defineCreateInterfaceObjectAction(interfaceType, objectType, validation
         required: prop.sharedPropertyType.array ?? false ? {
           listLength: {}
         } : prop.required,
-        allowedValues: extractAllowedValuesFromType(prop.sharedPropertyType.type)
+        allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
       }
     }))],
     status: interfaceType.status.type !== "deprecated" ? interfaceType.status.type : interfaceType.status,
@@ -1757,32 +1875,18 @@ function defineCreateInterfaceObjectAction(interfaceType, objectType, validation
   });
 }
 function defineCreateObjectAction(def) {
-  Object.keys(def.parameterLevelValidations ?? {}).forEach((id) => {
-    !(def.objectType.properties?.[id] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Property ${id} does not exist on ${def.objectType.apiName}`) : invariant5__default.default(false) : void 0;
-  });
-  (def.excludedProperties ?? []).forEach((id) => {
-    !(def.objectType.properties?.[id] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Property ${id} does not exist on ${def.objectType.apiName}`) : invariant5__default.default(false) : void 0;
-  });
-  const parameterNames = Object.keys(def.objectType.properties ?? {}).filter((id) => !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type));
-  const parameters = Array.from(parameterNames).map((id) => ({
-    id,
-    displayName: def.objectType.properties?.[id].displayName ?? convertToDisplayName(id),
-    type: extractActionParameterType(def.objectType.properties?.[id]),
-    validation: def.parameterLevelValidations?.[id] !== void 0 ? {
-      ...def.parameterLevelValidations?.[id],
-      allowedValues: def.parameterLevelValidations?.[id].allowedValues ?? extractAllowedValuesFromType(def.objectType.properties?.[id].type),
-      required: def.parameterLevelValidations?.[id].required ?? true
-    } : {
-      required: def.objectType.properties?.[id].array ?? false ? {
-        listLength: def.objectType.properties?.[id].nullability?.noEmptyCollections ? {
-          min: 1
-        } : {}
-      } : def.objectType.properties?.[id].nullability?.noNulls ?? true,
-      allowedValues: extractAllowedValuesFromType(def.objectType.properties?.[id].type)
-    }
-  }));
+  validateActionParameters(def);
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type));
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
+  const actionApiName = def.apiName ?? `create-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
+  if (def.parameterOrdering) {
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, parameterNames, true);
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
   return defineAction({
-    apiName: def.apiName ?? `create-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
+    apiName: actionApiName,
     displayName: def.displayName ?? `Create ${def.objectType.displayName}`,
     parameters,
     status: def.status ?? "active",
@@ -1796,16 +1900,35 @@ function defineCreateObjectAction(def) {
       type: "addObjectRule",
       addObjectRule: {
         objectTypeId: def.objectType.apiName,
-        propertyValues: Object.fromEntries(parameters.map((p) => [p.id, {
-          type: "parameterId",
-          parameterId: p.id
-        }])),
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map((p) => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
         structFieldValues: {}
       }
     }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters),
     ...def.actionLevelValidation ? {
       validation: [convertValidationRule(def.actionLevelValidation)]
-    } : {}
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.displayAndFormat && {
+      displayAndFormat: def.displayAndFormat
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
   });
 }
 function defineModifyInterfaceObjectAction(interfaceType, objectType, validation) {
@@ -1851,7 +1974,7 @@ function defineModifyInterfaceObjectAction(interfaceType, objectType, validation
         required: prop.sharedPropertyType.array ?? false ? {
           listLength: {}
         } : prop.required,
-        allowedValues: extractAllowedValuesFromType(prop.sharedPropertyType.type)
+        allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
       }
     }))],
     status: interfaceType.status.type !== "deprecated" ? interfaceType.status.type : interfaceType.status,
@@ -1877,58 +2000,47 @@ function defineModifyInterfaceObjectAction(interfaceType, objectType, validation
   });
 }
 function defineModifyObjectAction(def) {
-  Object.keys(def.parameterLevelValidations ?? {}).forEach((id) => {
-    !(def.objectType.properties?.[id] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Property ${id} does not exist on ${def.objectType.apiName}`) : invariant5__default.default(false) : void 0;
-  });
-  (def.excludedProperties ?? []).forEach((id) => {
-    !(def.objectType.properties?.[id] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Property ${id} does not exist on ${def.objectType.apiName}`) : invariant5__default.default(false) : void 0;
-  });
-  const parameterNames = Object.keys(def.objectType.properties ?? {}).filter((id) => !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
-  const parameters = Array.from(parameterNames).map((id) => ({
-    id,
-    displayName: def.objectType.properties?.[id].displayName ?? convertToDisplayName(id),
-    type: extractActionParameterType(def.objectType.properties?.[id]),
-    validation: def.parameterLevelValidations?.[id] !== void 0 ? {
-      ...def.parameterLevelValidations?.[id],
-      allowedValues: def.parameterLevelValidations?.[id].allowedValues ?? extractAllowedValuesFromType(def.objectType.properties?.[id].type),
-      required: def.parameterLevelValidations?.[id].required ?? false
-    } : {
-      required: def.objectType.properties?.[id].array ?? false ? {
-        listLength: def.objectType.properties?.[id].nullability?.noEmptyCollections ? {
-          min: 1
-        } : {}
-      } : def.objectType.properties?.[id].nullability?.noNulls ?? false,
-      allowedValues: extractAllowedValuesFromType(def.objectType.properties?.[id].type)
+  validateActionParameters(def);
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
+  parameterNames.add(MODIFY_OBJECT_PARAMETER);
+  const actionApiName = def.apiName ?? `modify-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(MODIFY_OBJECT_PARAMETER)) {
+      def.parameterOrdering = [MODIFY_OBJECT_PARAMETER, ...def.parameterOrdering];
     }
-  }));
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, parameterNames, false);
+  parameters.forEach((p) => {
+    if (p.id !== MODIFY_OBJECT_PARAMETER && p.defaultValue === void 0) {
+      p.defaultValue = {
+        type: "objectParameterPropertyValue",
+        objectParameterPropertyValue: {
+          parameterId: MODIFY_OBJECT_PARAMETER,
+          propertyTypeId: p.id
+        }
+      };
+    }
+  });
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
   return defineAction({
-    apiName: def.apiName ?? `modify-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
+    apiName: actionApiName,
     displayName: def.displayName ?? `Modify ${def.objectType.displayName}`,
-    parameters: [{
-      id: "objectToModifyParameter",
-      displayName: "Modify object",
-      type: {
-        type: "objectReference",
-        objectReference: {
-          objectTypeId: def.objectType.apiName
-        }
-      },
-      validation: {
-        allowedValues: {
-          type: "objectQuery"
-        },
-        required: true
-      }
-    }, ...parameters],
+    parameters,
     status: def.status ?? "active",
     rules: [{
       type: "modifyObjectRule",
       modifyObjectRule: {
-        objectToModify: "objectToModifyParameter",
-        propertyValues: Object.fromEntries(parameters.map((p) => [p.id, {
-          type: "parameterId",
-          parameterId: p.id
-        }])),
+        objectToModify: MODIFY_OBJECT_PARAMETER,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map((p) => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
         structFieldValues: {}
       }
     }],
@@ -1938,9 +2050,25 @@ function defineModifyObjectAction(def) {
       affectedLinkTypes: [],
       typeGroups: []
     },
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters, MODIFY_OBJECT_PARAMETER),
     ...def.actionLevelValidation ? {
       validation: [convertValidationRule(def.actionLevelValidation)]
-    } : {}
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.displayAndFormat && {
+      displayAndFormat: def.displayAndFormat
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
   });
 }
 function defineDeleteObjectAction(def) {
@@ -1981,6 +2109,78 @@ function defineDeleteObjectAction(def) {
     } : {}
   });
 }
+function defineCreateOrModifyObjectAction(def) {
+  validateActionParameters(def);
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => !Object.keys(def.nonParameterMappings ?? {}).includes(id) && !def.excludedProperties?.includes(id) && !isStruct(def.objectType.properties?.[id].type) && id !== def.objectType.primaryKeyPropertyApiName);
+  const parameterNames = new Set(propertyParameters);
+  Object.keys(def.parameterConfiguration ?? {}).forEach((param) => parameterNames.add(param));
+  parameterNames.add(CREATE_OR_MODIFY_OBJECT_PARAMETER);
+  const actionApiName = def.apiName ?? `create-or-modify-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(CREATE_OR_MODIFY_OBJECT_PARAMETER)) {
+      def.parameterOrdering = [CREATE_OR_MODIFY_OBJECT_PARAMETER, ...def.parameterOrdering];
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, parameterNames, false);
+  parameters.forEach((p) => {
+    if (p.id !== CREATE_OR_MODIFY_OBJECT_PARAMETER && p.defaultValue === void 0) {
+      p.defaultValue = {
+        type: "objectParameterPropertyValue",
+        objectParameterPropertyValue: {
+          parameterId: CREATE_OR_MODIFY_OBJECT_PARAMETER,
+          propertyTypeId: p.id
+        }
+      };
+    }
+  });
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Create or Modify ${def.objectType.displayName}`,
+    parameters,
+    status: def.status ?? "active",
+    rules: [{
+      type: "addOrModifyObjectRuleV2",
+      addOrModifyObjectRuleV2: {
+        objectToModify: CREATE_OR_MODIFY_OBJECT_PARAMETER,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map((p) => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
+        structFieldValues: {}
+      }
+    }],
+    entities: {
+      affectedInterfaceTypes: [],
+      affectedObjectTypes: [def.objectType.apiName],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, parameters, CREATE_OR_MODIFY_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: [convertValidationRule(def.actionLevelValidation)]
+    } : {},
+    ...def.defaultFormat && {
+      defaultFormat: def.defaultFormat
+    },
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.displayAndFormat && {
+      displayAndFormat: def.displayAndFormat
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
+  });
+}
 function defineAction(actionDef) {
   const apiName = namespace + actionDef.apiName;
   const parameterIds = (actionDef.parameters ?? []).map((p) => p.id);
@@ -2015,13 +2215,88 @@ function defineAction(actionDef) {
     },
     __type: OntologyEntityTypeEnum.ACTION_TYPE
   };
-  validateActionValidation(fullAction);
+  validateActionConfiguration(fullAction);
   updateOntology(fullAction);
   return fullAction;
 }
+function createParameters(def, parameterSet, defaultRequired) {
+  const targetParam = [];
+  parameterSet.forEach((name) => {
+    if (name === MODIFY_OBJECT_PARAMETER) {
+      targetParam.push({
+        id: MODIFY_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Modify object",
+        type: {
+          type: "objectReference",
+          objectReference: {
+            objectTypeId: def.objectType.apiName
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          allowedValues: {
+            type: "objectQuery"
+          },
+          required: def.parameterConfiguration?.[name]?.required ?? true
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(MODIFY_OBJECT_PARAMETER);
+    }
+    if (name === CREATE_OR_MODIFY_OBJECT_PARAMETER) {
+      targetParam.push({
+        id: CREATE_OR_MODIFY_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Create or modify object",
+        type: {
+          type: "objectReference",
+          objectReference: {
+            objectTypeId: def.objectType.apiName,
+            maybeCreateObjectOption: !def.primaryKeyOption || def.primaryKeyOption === "autoGenerated" ? {
+              type: "autoGenerated",
+              autoGenerated: {}
+            } : {
+              type: "userInput",
+              userInput: {}
+            }
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          allowedValues: {
+            type: "objectQuery"
+          },
+          required: def.parameterConfiguration?.[name]?.required ?? true
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(CREATE_OR_MODIFY_OBJECT_PARAMETER);
+    }
+  });
+  return [...targetParam, ...Array.from(parameterSet).map((id) => ({
+    id,
+    displayName: def.parameterConfiguration?.[id]?.displayName ?? def.objectType.properties?.[id]?.displayName ?? convertToDisplayName(id),
+    type: def.parameterConfiguration?.[id]?.customParameterType ?? extractActionParameterType(def.objectType.properties?.[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(def.objectType.properties?.[id].type)),
+      required: def.parameterConfiguration?.[id].required ?? defaultRequired
+    } : {
+      required: def.objectType.properties?.[id].array ?? false ? {
+        listLength: def.objectType.properties?.[id].nullability?.noEmptyCollections ? {
+          min: 1
+        } : {}
+      } : def.objectType.properties?.[id].nullability?.noNulls ?? defaultRequired,
+      allowedValues: extractAllowedValuesFromPropertyType(def.objectType.properties?.[id].type)
+    },
+    defaultValue: def.parameterConfiguration?.[id]?.defaultValue,
+    description: def.parameterConfiguration?.[id]?.description
+  }))];
+}
 function referencedParameterIds(actionDef) {
   const parameterIds = /* @__PURE__ */ new Set();
-  Object.values(actionDef.sections ?? {}).flatMap((p) => p).forEach((pId) => parameterIds.add(pId));
+  Object.values(actionDef.sections ?? {}).flatMap((p) => p.parameters).forEach((pId) => parameterIds.add(pId));
   (actionDef.formContentOrdering ?? []).forEach((item) => {
     if (item.type === "parameterId") {
       parameterIds.add(item.parameterId);
@@ -2075,7 +2350,80 @@ function referencedParameterIds(actionDef) {
   });
   return parameterIds;
 }
-function extractAllowedValuesFromType(type) {
+function extractAllowedValuesFromActionParameterType(type) {
+  if (typeof type === "object") {
+    switch (type.type) {
+      case "objectReference":
+      case "objectReferenceList":
+        return {
+          type: "objectQuery"
+        };
+      case "struct":
+      case "structList":
+        throw new Error("Structs are not supported yet");
+      default:
+        throw new Error(`Inferred allowed values for ${type.type} not yet supported. Please explicitly provide allowed values.`);
+    }
+  }
+  switch (type) {
+    case "boolean":
+    case "booleanList":
+      return {
+        type: "boolean"
+      };
+    case "integer":
+    case "integerList":
+    case "decimal":
+    case "decimalList":
+    case "double":
+    case "doubleList":
+    case "long":
+    case "longList":
+      return {
+        type: "range"
+      };
+    case "timestamp":
+    case "timestampList":
+    case "date":
+    case "dateList":
+      return {
+        type: "datetime"
+      };
+    case "string":
+    case "stringList":
+      return {
+        type: "text"
+      };
+    case "geohash":
+    case "geohashList":
+      return {
+        type: "geohash"
+      };
+    case "geoshape":
+    case "geoshapeList":
+      return {
+        type: "geoshape"
+      };
+    case "mediaReference":
+    case "mediaReferenceList":
+      return {
+        type: "mediaReference"
+      };
+    case "geotimeSeriesReference":
+    case "geotimeSeriesReferenceList":
+      return {
+        type: "geotimeSeriesReference"
+      };
+    case "attachment":
+    case "attachmentList":
+      return {
+        type: "attachment"
+      };
+    default:
+      throw new Error(`Inferred allowed values for ${type} not yet supported. Please explicitly provide allowed values.`);
+  }
+}
+function extractAllowedValuesFromPropertyType(type) {
   switch (type) {
     case "boolean":
       return {
@@ -2158,6 +2506,10 @@ function extractAllowedValuesFromType(type) {
           } : {
             type: "mandatoryMarking"
           };
+        case "string":
+          return {
+            type: "text"
+          };
         case "struct":
           throw new Error("Structs are not supported yet");
         default:
@@ -2171,6 +2523,8 @@ function extractActionParameterType(pt) {
     switch (typeType.type) {
       case "marking":
         return maybeAddList("marking", pt);
+      case "string":
+        return maybeAddList("string", pt);
       case "struct":
         throw new Error("Structs are not supported yet");
       default:
@@ -2218,16 +2572,22 @@ function convertValidationRule(actionValidation) {
     }
   };
 }
-function validateActionValidation(action) {
+function validateActionConfiguration(action) {
   const seenParameterIds = /* @__PURE__ */ new Set();
-  action.parameters?.forEach((param) => {
+  const parameterMap = action.parameters?.reduce((acc, param) => {
+    acc[param.id] = param;
+    return acc;
+  }, {}) ?? {};
+  const orderedParameters = action.parameterOrdering?.map((id) => parameterMap[id]) ?? action.parameters;
+  orderedParameters?.forEach((param) => {
     param.validation.conditionalOverrides?.forEach((override) => {
-      validateActionCondition(override.condition, param.id, seenParameterIds, action.parameters);
+      validateParameterCondition(override.condition, param.id, seenParameterIds, action.parameters);
     });
+    validateParameterPrefill(param.id, seenParameterIds, action.parameters, param.defaultValue);
     seenParameterIds.add(param.id);
   });
 }
-function validateActionCondition(condition, currentParameterId, seenParameterIds, parameters) {
+function validateParameterCondition(condition, currentParameterId, seenParameterIds, parameters) {
   switch (condition.type) {
     case "parameter":
       const overrideParamId = condition.parameterId;
@@ -2237,12 +2597,12 @@ function validateActionCondition(condition, currentParameterId, seenParameterIds
       break;
     case "and":
       if ("conditions" in condition) {
-        condition.conditions.forEach((c) => validateActionCondition(c, currentParameterId, seenParameterIds, parameters));
+        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
       }
       break;
     case "or":
       if ("conditions" in condition) {
-        condition.conditions.forEach((c) => validateActionCondition(c, currentParameterId, seenParameterIds, parameters));
+        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
       }
       break;
     case "comparison":
@@ -2257,6 +2617,44 @@ function validateActionCondition(condition, currentParameterId, seenParameterIds
       throw new Error(`Unknown condition type on parameter ${currentParameterId}`);
   }
 }
+function validateParameterPrefill(currentParameterId, seenParameterIds, parameters, defaultValue) {
+  if (!defaultValue) return;
+  switch (defaultValue.type) {
+    case "objectParameterPropertyValue":
+      !parameters?.some((p) => p.id === defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Default value for parameter ${currentParameterId} is referencing unknown parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant5__default.default(false) : void 0;
+      !seenParameterIds.has(defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Default value for parameter ${currentParameterId} is referencing later parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant5__default.default(false) : void 0;
+      break;
+    case "staticValue":
+      !(defaultValue.staticValue.type === parameters?.find((p) => p.id === currentParameterId)?.type) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Default static value for parameter ${currentParameterId} does not match type`) : invariant5__default.default(false) : void 0;
+      break;
+    case "staticObject":
+    case "interfaceParameterPropertyValue":
+    case "objectQueryPrefill":
+    case "objectQueryPropertyValue":
+    case "objectSetRidPrefill":
+    case "redacted":
+      break;
+    default:
+      throw new Error(`Unknown default value type for parameter ${currentParameterId}`);
+  }
+}
+function validateActionParameters(def) {
+  [...Object.keys(def.parameterConfiguration ?? {})].forEach((id) => {
+    !(def.objectType.properties?.[id] !== void 0 || def.parameterConfiguration?.[id].customParameterType !== void 0 || id === MODIFY_OBJECT_PARAMETER || id === CREATE_OR_MODIFY_OBJECT_PARAMETER) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Parameter ${id} does not exist as a property on ${def.objectType.apiName} and its type is not explicitly defined`) : invariant5__default.default(false) : void 0;
+  });
+  [...Object.keys(def.nonParameterMappings ?? {}), ...def.excludedProperties ?? []].forEach((id) => {
+    !(def.objectType.properties?.[id] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Property ${id} does not exist as a property on ${def.objectType.apiName}`) : invariant5__default.default(false) : void 0;
+  });
+}
+function createDefaultParameterOrdering(def, parameters, priorityId) {
+  return [...priorityId ? [priorityId] : [], ...Object.keys(def.parameterConfiguration ?? {}), ...Object.keys(def.objectType.properties ?? {}).filter((id) => !def.parameterConfiguration?.[id] && parameters.some((p) => p.id === id))];
+}
+function validateParameterOrdering(parameterOrdering, parameterSet, actionApiName) {
+  const orderingSet = new Set(parameterOrdering);
+  const missingParameters = [...parameterSet].filter((param) => !orderingSet.has(param));
+  const extraneousParameters = parameterOrdering.filter((param) => !parameterSet.has(param));
+  !(extraneousParameters.length === 0 && missingParameters.length === 0) ? process.env.NODE_ENV !== "production" ? invariant5__default.default(false, `Action parameter ordering for ${actionApiName} does not match expected parameters. Extraneous parameters in ordering: {${extraneousParameters}}, Missing parameters in ordering: {${missingParameters}}`) : invariant5__default.default(false) : void 0;
+}
 
 // src/api/importOntologyEntity.ts
 function importOntologyEntity(e) {
@@ -2578,12 +2976,19 @@ function wrapWithProxy(entity) {
   });
 }
 
+exports.CREATE_OR_MODIFY_OBJECT_PARAMETER = CREATE_OR_MODIFY_OBJECT_PARAMETER;
+exports.MODIFY_OBJECT_PARAMETER = MODIFY_OBJECT_PARAMETER;
 exports.OntologyEntityTypeEnum = OntologyEntityTypeEnum;
 exports.addDependency = addDependency;
+exports.addNamespaceIfNone = addNamespaceIfNone;
+exports.convertToDisplayName = convertToDisplayName;
+exports.convertToPluralDisplayName = convertToPluralDisplayName;
+exports.convertType = convertType;
 exports.default = main;
 exports.defineAction = defineAction;
 exports.defineCreateInterfaceObjectAction = defineCreateInterfaceObjectAction;
 exports.defineCreateObjectAction = defineCreateObjectAction;
+exports.defineCreateOrModifyObjectAction = defineCreateOrModifyObjectAction;
 exports.defineDeleteObjectAction = defineDeleteObjectAction;
 exports.defineInterface = defineInterface;
 exports.defineInterfaceLinkConstraint = defineInterfaceLinkConstraint;
@@ -2594,6 +2999,7 @@ exports.defineObject = defineObject;
 exports.defineOntology = defineOntology;
 exports.defineSharedPropertyType = defineSharedPropertyType;
 exports.defineValueType = defineValueType;
+exports.dumpOntologyFullMetadata = dumpOntologyFullMetadata;
 exports.importOntologyEntity = importOntologyEntity;
 exports.importSharedPropertyType = importSharedPropertyType;
 exports.wrapWithProxy = wrapWithProxy;