@osdk/maker 0.14.0-beta.3 → 0.14.0-beta.5

package/build/cjs/index.cjs

@@ -1705,7 +1705,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.14.0-beta.3").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
+  const commandLineOpts = await yargs__default.default(helpers.hideBin(args)).version("0.14.0-beta.5").wrap(Math.min(150, yargs__default.default().terminalWidth())).strict().help().options({
     input: {
       alias: "i",
       describe: "Input file",
@@ -1796,29 +1796,6 @@ function addDependency(namespaceNoDot, fileInPackage) {
   const packageJson = JSON.parse(fs__namespace.readFileSync(packageJsonPath, "utf-8"));
   dependencies[namespaceNoDot] = packageJson.version ?? "";
 }
-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;
-  }
-}
 
 // src/api/action/ActionParameterType.ts
 function isActionParameterTypePrimitive(type) {
@@ -1828,383 +1805,8 @@ function isActionParameterTypePrimitive(type) {
 // src/api/defineAction.ts
 var MODIFY_OBJECT_PARAMETER = "objectToModifyParameter";
 var CREATE_OR_MODIFY_OBJECT_PARAMETER = "objectToCreateOrModifyParameter";
-function defineCreateInterfaceObjectAction(def) {
-  const allProperties = Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type) && !(def.excludedProperties ?? []).includes(prop.sharedPropertyType.nonNameSpacedApiName));
-  if (allProperties.length !== Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).length) {
-    consola.consola.info(`Some properties on ${def.interfaceType.apiName} were skipped in the create action because they are structs`);
-  }
-  return defineAction({
-    apiName: `create-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`,
-    displayName: `Create ${def.interfaceType.displayMetadata.displayName}`,
-    parameters: [{
-      id: "objectTypeParameter",
-      displayName: "Object type to create",
-      type: {
-        type: "objectTypeReference",
-        objectTypeReference: {
-          interfaceTypeRids: [def.interfaceType.apiName]
-        }
-      },
-      validation: {
-        required: true,
-        allowedValues: def.objectType === void 0 ? {
-          type: "objectTypeReference",
-          interfaceTypes: [def.interfaceType.apiName]
-        } : {
-          type: "oneOf",
-          oneOf: [{
-            label: def.objectType.displayName,
-            value: {
-              type: "objectType",
-              objectType: {
-                objectTypeId: def.objectType.apiName
-              }
-            }
-          }]
-        }
-      }
-    }, ...allProperties.map(([id, prop]) => ({
-      id,
-      displayName: prop.sharedPropertyType.displayName ?? prop.sharedPropertyType.nonNameSpacedApiName,
-      type: extractActionParameterType(prop.sharedPropertyType),
-      typeClasses: prop.sharedPropertyType.typeClasses ?? [],
-      validation: {
-        required: prop.sharedPropertyType.array ?? false ? {
-          listLength: {}
-        } : prop.required,
-        allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
-      }
-    }))],
-    status: def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status,
-    entities: {
-      affectedInterfaceTypes: [def.interfaceType.apiName],
-      affectedObjectTypes: [],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    rules: [{
-      type: "addInterfaceRule",
-      addInterfaceRule: {
-        interfaceApiName: def.interfaceType.apiName,
-        objectTypeParameter: "objectTypeParameter",
-        sharedPropertyValues: Object.fromEntries(allProperties.map(([id, _prop]) => [id, {
-          type: "parameterId",
-          parameterId: id
-        }]))
-      }
-    }],
-    ...def.validation ? {
-      validation: convertValidationRule(def.validation)
-    } : {}
-  });
-}
-function defineCreateObjectAction(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));
-  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);
-  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
-  return defineAction({
-    apiName: actionApiName,
-    displayName: def.displayName ?? `Create ${def.objectType.displayName}`,
-    parameters,
-    status: def.status ?? "active",
-    entities: {
-      affectedInterfaceTypes: [],
-      affectedObjectTypes: [def.objectType.apiName],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    rules: [{
-      type: "addObjectRule",
-      addObjectRule: {
-        objectTypeId: def.objectType.apiName,
-        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, parameters)
-    } : {},
-    ...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(def) {
-  const allProperties = Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type) && !(def.excludedProperties ?? []).includes(prop.sharedPropertyType.nonNameSpacedApiName));
-  if (allProperties.length !== Object.entries(getFlattenedInterfaceProperties(def.interfaceType)).length) {
-    consola.consola.info(`Some properties on ${def.interfaceType.apiName} were skipped in the modify action because they are structs`);
-  }
-  return defineAction({
-    apiName: `modify-${kebab(def.interfaceType.apiName.split(".").pop() ?? def.interfaceType.apiName)}${def.objectType === void 0 ? "" : `-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`}`,
-    displayName: `Modify ${def.interfaceType.displayMetadata.displayName}`,
-    parameters: [{
-      id: "interfaceObjectToModifyParameter",
-      displayName: "Object type to modify",
-      type: {
-        type: "interfaceReference",
-        interfaceReference: {
-          interfaceTypeRid: def.interfaceType.apiName
-        }
-      },
-      validation: {
-        required: true,
-        allowedValues: def.objectType === void 0 ? {
-          type: "interfaceObjectQuery"
-        } : {
-          type: "oneOf",
-          oneOf: [{
-            label: def.objectType.displayName,
-            value: {
-              type: "objectType",
-              objectType: {
-                objectTypeId: def.objectType.apiName
-              }
-            }
-          }]
-        }
-      }
-    }, ...allProperties.map(([id, prop]) => ({
-      id,
-      displayName: prop.sharedPropertyType.displayName ?? prop.sharedPropertyType.nonNameSpacedApiName,
-      type: extractActionParameterType(prop.sharedPropertyType),
-      typeClasses: prop.sharedPropertyType.typeClasses ?? [],
-      validation: {
-        required: prop.sharedPropertyType.array ?? false ? {
-          listLength: {}
-        } : prop.required,
-        allowedValues: extractAllowedValuesFromPropertyType(prop.sharedPropertyType.type)
-      }
-    }))],
-    status: def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status,
-    entities: {
-      affectedInterfaceTypes: [def.interfaceType.apiName],
-      affectedObjectTypes: [],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    rules: [{
-      type: "modifyInterfaceRule",
-      modifyInterfaceRule: {
-        interfaceObjectToModifyParameter: "interfaceObjectToModifyParameter",
-        sharedPropertyValues: Object.fromEntries(allProperties.map(([id, _prop]) => [id, {
-          type: "parameterId",
-          parameterId: id
-        }]))
-      }
-    }],
-    ...def.validation ? {
-      validation: convertValidationRule(def.validation)
-    } : {}
-  });
-}
-function defineModifyObjectAction(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(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);
-  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: actionApiName,
-    displayName: def.displayName ?? `Modify ${def.objectType.displayName}`,
-    parameters,
-    status: def.status ?? "active",
-    rules: [{
-      type: "modifyObjectRule",
-      modifyObjectRule: {
-        objectToModify: 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, MODIFY_OBJECT_PARAMETER),
-    ...def.actionLevelValidation ? {
-      validation: convertValidationRule(def.actionLevelValidation, parameters)
-    } : {},
-    ...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) {
-  return defineAction({
-    apiName: def.apiName ?? `delete-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
-    displayName: def.displayName ?? `Delete ${def.objectType.displayName}`,
-    parameters: [{
-      id: "objectToDeleteParameter",
-      displayName: "Delete object",
-      type: {
-        type: "objectReference",
-        objectReference: {
-          objectTypeId: def.objectType.apiName
-        }
-      },
-      validation: {
-        required: true,
-        allowedValues: {
-          type: "objectQuery"
-        }
-      }
-    }],
-    status: def.status ?? "active",
-    rules: [{
-      type: "deleteObjectRule",
-      deleteObjectRule: {
-        objectToDelete: "objectToDeleteParameter"
-      }
-    }],
-    entities: {
-      affectedInterfaceTypes: [],
-      affectedObjectTypes: [def.objectType.apiName],
-      affectedLinkTypes: [],
-      typeGroups: []
-    },
-    ...def.actionLevelValidation ? {
-      validation: convertValidationRule(def.actionLevelValidation)
-    } : {}
-  });
-}
-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);
-  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, parameters)
-    } : {},
-    ...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
-    }
-  });
-}
+var CREATE_INTERFACE_OBJECT_PARAMETER = "objectTypeParameter";
+var MODIFY_INTERFACE_OBJECT_PARAMETER = "interfaceObjectToModifyParameter";
 function defineAction(actionDef) {
   const apiName = namespace + actionDef.apiName;
   const parameterIds = (actionDef.parameters ?? []).map((p) => p.id);
@@ -2260,11 +1862,36 @@ function defineAction(actionDef) {
   updateOntology(fullAction);
   return fullAction;
 }
-function createParameters(def, parameterSet) {
-  const targetParam = [];
+function isPropertyParameter(def, name, type) {
+  return !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
+  }))];
+}
+function getTargetParameters(def, parameterSet) {
+  const targetParams = [];
   parameterSet.forEach((name) => {
     if (name === MODIFY_OBJECT_PARAMETER) {
-      targetParam.push({
+      targetParams.push({
         id: MODIFY_OBJECT_PARAMETER,
         displayName: def.parameterConfiguration?.[name]?.displayName ?? "Modify object",
         type: {
@@ -2286,14 +1913,17 @@ function createParameters(def, parameterSet) {
       parameterSet.delete(MODIFY_OBJECT_PARAMETER);
     }
     if (name === CREATE_OR_MODIFY_OBJECT_PARAMETER) {
-      targetParam.push({
+      targetParams.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" ? {
+            maybeCreateObjectOption: !("primaryKeyOption" in def) ? {
+              type: "autoGenerated",
+              autoGenerated: {}
+            } : def.primaryKeyOption === "autoGenerated" ? {
               type: "autoGenerated",
               autoGenerated: {}
             } : {
@@ -2304,36 +1934,85 @@ function createParameters(def, parameterSet) {
         },
         validation: {
           ...def.parameterConfiguration?.[name],
-          allowedValues: {
-            type: "objectQuery"
-          },
-          required: def.parameterConfiguration?.[name]?.required ?? true
+          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);
+    }
+    if (name === CREATE_INTERFACE_OBJECT_PARAMETER && "interfaceType" in def) {
+      targetParams.push({
+        id: CREATE_INTERFACE_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Object type to create",
+        type: {
+          type: "objectTypeReference",
+          objectTypeReference: {
+            interfaceTypeRids: [def.interfaceType.apiName]
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          required: true,
+          allowedValues: def.objectType === void 0 ? {
+            type: "objectTypeReference",
+            interfaceTypes: [def.interfaceType.apiName]
+          } : {
+            type: "oneOf",
+            oneOf: [{
+              label: def.objectType.displayName,
+              value: {
+                type: "objectType",
+                objectType: {
+                  objectTypeId: def.objectType.apiName
+                }
+              }
+            }]
+          }
+        },
+        defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
+        description: def.parameterConfiguration?.[name]?.description
+      });
+      parameterSet.delete(CREATE_INTERFACE_OBJECT_PARAMETER);
+    }
+    if (name === MODIFY_INTERFACE_OBJECT_PARAMETER && "interfaceType" in def) {
+      targetParams.push({
+        id: MODIFY_INTERFACE_OBJECT_PARAMETER,
+        displayName: def.parameterConfiguration?.[name]?.displayName ?? "Object type to modify",
+        type: {
+          type: "interfaceReference",
+          interfaceReference: {
+            interfaceTypeRid: def.interfaceType.apiName
+          }
+        },
+        validation: {
+          ...def.parameterConfiguration?.[name],
+          required: true,
+          allowedValues: def.objectType === void 0 ? {
+            type: "interfaceObjectQuery"
+          } : {
+            type: "oneOf",
+            oneOf: [{
+              label: def.objectType.displayName,
+              value: {
+                type: "objectType",
+                objectType: {
+                  objectTypeId: def.objectType.apiName
+                }
+              }
+            }]
+          }
         },
         defaultValue: def.parameterConfiguration?.[name]?.defaultValue,
         description: def.parameterConfiguration?.[name]?.description
       });
-      parameterSet.delete(CREATE_OR_MODIFY_OBJECT_PARAMETER);
+      parameterSet.delete(MODIFY_INTERFACE_OBJECT_PARAMETER);
     }
   });
-  return [...targetParam, ...Array.from(parameterSet).map((id) => ({
-    id,
-    displayName: def.parameterConfiguration?.[id]?.displayName ?? def.objectType.properties?.[id]?.displayName ?? uppercaseFirstLetter(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 ?? def.objectType.properties?.[id]?.nullability?.noNulls ?? 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: extractAllowedValuesFromPropertyType(def.objectType.properties?.[id].type)
-    },
-    defaultValue: def.parameterConfiguration?.[id]?.defaultValue,
-    description: def.parameterConfiguration?.[id]?.description
-  }))];
+  return targetParams;
 }
 function referencedParameterIds(actionDef) {
   const parameterIds = /* @__PURE__ */ new Set();
@@ -2606,92 +2285,362 @@ function convertValidationRule(actionValidation, actionParameters) {
         failureMessage: "Did not satisfy validation",
         typeClasses: []
       }
-    };
-  });
-}
-function validateActionConfiguration(action) {
-  const seenParameterIds = /* @__PURE__ */ new Set();
-  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) => {
-      validateParameterCondition(override.condition, param.id, seenParameterIds, action.parameters);
-    });
-    validateParameterPrefill(param.id, seenParameterIds, action.parameters, param.defaultValue);
-    seenParameterIds.add(param.id);
+    };
+  });
+}
+function validateActionConfiguration(action) {
+  const seenParameterIds = /* @__PURE__ */ new Set();
+  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) => {
+      validateParameterCondition(override.condition, param.id, seenParameterIds, action.parameters);
+    });
+    validateParameterPrefill(param.id, seenParameterIds, action.parameters, param.defaultValue);
+    seenParameterIds.add(param.id);
+  });
+}
+function validateParameterCondition(condition, currentParameterId, seenParameterIds, parameters) {
+  switch (condition.type) {
+    case "parameter":
+      const overrideParamId = condition.parameterId;
+      !parameters?.some((p) => p.id === overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing unknown parameter ${overrideParamId}`) : invariant6__default.default(false) : void 0;
+      !(overrideParamId !== currentParameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing itself`) : invariant6__default.default(false) : void 0;
+      !seenParameterIds.has(overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing later parameter ${overrideParamId}`) : invariant6__default.default(false) : void 0;
+      break;
+    case "and":
+      if ("conditions" in condition) {
+        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+      }
+      break;
+    case "or":
+      if ("conditions" in condition) {
+        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+      }
+      break;
+    case "comparison":
+    case "group":
+    case "not":
+    case "markings":
+    case "regex":
+    case "redacted":
+    case "true":
+      break;
+    default:
+      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" ? invariant6__default.default(false, `Default value for parameter ${currentParameterId} is referencing unknown parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant6__default.default(false) : void 0;
+      !seenParameterIds.has(defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Default value for parameter ${currentParameterId} is referencing later parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant6__default.default(false) : void 0;
+      break;
+    case "staticValue":
+      !(defaultValue.staticValue.type === parameters?.find((p) => p.id === currentParameterId)?.type) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Default static value for parameter ${currentParameterId} does not match type`) : invariant6__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, properties, name) {
+  [...Object.keys(def.parameterConfiguration ?? {})].forEach((id) => {
+    !(properties.includes(id) || properties.includes(addNamespaceIfNone(id)) || def.parameterConfiguration?.[id].customParameterType !== void 0 || isTargetParameter(id)) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter ${id} does not exist as a property on ${name} and its type is not explicitly defined`) : invariant6__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" ? invariant6__default.default(false, `Property ${id} does not exist as a property on ${name}`) : invariant6__default.default(false) : void 0;
+  });
+}
+function createDefaultParameterOrdering(def, properties, parameters, priorityId) {
+  return [...priorityId ? [priorityId] : [], ...Object.keys(def.parameterConfiguration ?? {}).filter((id) => id !== priorityId), ...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" ? invariant6__default.default(false, `Action parameter ordering for ${actionApiName} does not match expected parameters. Extraneous parameters in ordering: {${extraneousParameters}}, Missing parameters in ordering: {${missingParameters}}`) : invariant6__default.default(false) : void 0;
+}
+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) {
+  return isTargetParameter(parameter) || !Object.keys(def.interfaceType.propertiesV2).includes(addNamespaceIfNone(parameter)) ? parameter : addNamespaceIfNone(parameter);
+}
+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;
+  }
+}
+
+// src/api/defineCreateInterfaceObjectAction.ts
+function defineCreateInterfaceObjectAction(def) {
+  addNamespaceToActionDefinition(def);
+  const allProperties = getFlattenedInterfaceProperties(def.interfaceType);
+  validateActionParameters(def, Object.keys(allProperties), def.interfaceType.apiName);
+  const propertyParameters = Object.keys(allProperties).filter((apiName) => isPropertyParameter(def, apiName, allProperties[apiName].sharedPropertyType.type));
+  const parameterNames = new Set(propertyParameters);
+  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)}`}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(CREATE_INTERFACE_OBJECT_PARAMETER)) {
+      def.parameterOrdering.unshift(CREATE_INTERFACE_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.sharedPropertyType])), 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)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Create ${def.interfaceType.displayMetadata.displayName}`,
+    parameters,
+    status: def.status ?? (def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status),
+    entities: {
+      affectedInterfaceTypes: [def.interfaceType.apiName],
+      affectedObjectTypes: [],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    rules: [{
+      type: "addInterfaceRule",
+      addInterfaceRule: {
+        interfaceApiName: def.interfaceType.apiName,
+        objectTypeParameter: CREATE_INTERFACE_OBJECT_PARAMETER,
+        sharedPropertyValues: {
+          ...Object.fromEntries(propertyParameters.map((id) => [id, {
+            type: "parameterId",
+            parameterId: id
+          }])),
+          ...mappings
+        }
+      }
+    }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(allProperties), parameters, CREATE_INTERFACE_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      actionLevelValidation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
+  });
+}
+
+// src/api/defineCreateObjectAction.ts
+function defineCreateObjectAction(def) {
+  validateActionParameters(def, Object.keys(def.objectType.properties ?? {}), def.objectType.apiName);
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => isPropertyParameter(def, id, 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, def.objectType.properties ?? {}, parameterNames);
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Create ${def.objectType.displayName}`,
+    parameters,
+    status: def.status ?? "active",
+    entities: {
+      affectedInterfaceTypes: [],
+      affectedObjectTypes: [def.objectType.apiName],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    rules: [{
+      type: "addObjectRule",
+      addObjectRule: {
+        objectTypeId: def.objectType.apiName,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map((p) => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
+        structFieldValues: {}
+      }
+    }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(def.objectType.properties ?? {}), parameters),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...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
+    }
+  });
+}
+
+// src/api/defineCreateOrModifyObjectAction.ts
+function defineCreateOrModifyObjectAction(def) {
+  validateActionParameters(def, Object.keys(def.objectType.properties ?? {}), def.objectType.apiName);
+  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.unshift(CREATE_OR_MODIFY_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, def.objectType.properties ?? {}, parameterNames);
+  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, Object.keys(def.objectType.properties ?? {}), parameters, CREATE_OR_MODIFY_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...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 validateParameterCondition(condition, currentParameterId, seenParameterIds, parameters) {
-  switch (condition.type) {
-    case "parameter":
-      const overrideParamId = condition.parameterId;
-      !parameters?.some((p) => p.id === overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing unknown parameter ${overrideParamId}`) : invariant6__default.default(false) : void 0;
-      !(overrideParamId !== currentParameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing itself`) : invariant6__default.default(false) : void 0;
-      !seenParameterIds.has(overrideParamId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Parameter condition on ${currentParameterId} is referencing later parameter ${overrideParamId}`) : invariant6__default.default(false) : void 0;
-      break;
-    case "and":
-      if ("conditions" in condition) {
-        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+
+// src/api/defineDeleteObjectAction.ts
+function defineDeleteObjectAction(def) {
+  return defineAction({
+    apiName: def.apiName ?? `delete-object-${kebab(def.objectType.apiName.split(".").pop() ?? def.objectType.apiName)}`,
+    displayName: def.displayName ?? `Delete ${def.objectType.displayName}`,
+    parameters: [{
+      id: "objectToDeleteParameter",
+      displayName: "Delete object",
+      type: {
+        type: "objectReference",
+        objectReference: {
+          objectTypeId: def.objectType.apiName
+        }
+      },
+      validation: {
+        required: true,
+        allowedValues: {
+          type: "objectQuery"
+        }
       }
-      break;
-    case "or":
-      if ("conditions" in condition) {
-        condition.conditions.forEach((c) => validateParameterCondition(c, currentParameterId, seenParameterIds, parameters));
+    }],
+    status: def.status ?? "active",
+    rules: [{
+      type: "deleteObjectRule",
+      deleteObjectRule: {
+        objectToDelete: "objectToDeleteParameter"
       }
-      break;
-    case "comparison":
-    case "group":
-    case "not":
-    case "markings":
-    case "regex":
-    case "redacted":
-    case "true":
-      break;
-    default:
-      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" ? invariant6__default.default(false, `Default value for parameter ${currentParameterId} is referencing unknown parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant6__default.default(false) : void 0;
-      !seenParameterIds.has(defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Default value for parameter ${currentParameterId} is referencing later parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant6__default.default(false) : void 0;
-      break;
-    case "staticValue":
-      !(defaultValue.staticValue.type === parameters?.find((p) => p.id === currentParameterId)?.type) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Default static value for parameter ${currentParameterId} does not match type`) : invariant6__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" ? invariant6__default.default(false, `Parameter ${id} does not exist as a property on ${def.objectType.apiName} and its type is not explicitly defined`) : invariant6__default.default(false) : void 0;
-  });
-  [...Object.keys(def.nonParameterMappings ?? {}), ...def.excludedProperties ?? []].forEach((id) => {
-    !(def.objectType.properties?.[id] !== void 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Property ${id} does not exist as a property on ${def.objectType.apiName}`) : invariant6__default.default(false) : void 0;
+    }],
+    entities: {
+      affectedInterfaceTypes: [],
+      affectedObjectTypes: [def.objectType.apiName],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation)
+    } : {}
   });
 }
-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" ? invariant6__default.default(false, `Action parameter ordering for ${actionApiName} does not match expected parameters. Extraneous parameters in ordering: {${extraneousParameters}}, Missing parameters in ordering: {${missingParameters}}`) : invariant6__default.default(false) : void 0;
-}
 function defineSharedPropertyType(sptDef) {
   const apiName = namespace + sptDef.apiName;
   !(ontologyDefinition[OntologyEntityTypeEnum.SHARED_PROPERTY_TYPE][apiName] === void 0) ? process.env.NODE_ENV !== "production" ? invariant6__default.default(false, `Shared property type ${apiName} already exists`) : invariant6__default.default(false) : void 0;
@@ -2907,6 +2856,138 @@ function convertLinkTypeMetadata(metadata) {
     typeClasses: []
   };
 }
+
+// src/api/defineModifyInterfaceObjectAction.ts
+function defineModifyInterfaceObjectAction(def) {
+  addNamespaceToActionDefinition(def);
+  const allProperties = getFlattenedInterfaceProperties(def.interfaceType);
+  validateActionParameters(def, Object.keys(allProperties), def.interfaceType.apiName);
+  const propertyParameters = Object.keys(allProperties).filter((apiName) => isPropertyParameter(def, apiName, allProperties[apiName].sharedPropertyType.type));
+  const parameterNames = new Set(propertyParameters);
+  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)}`}`;
+  if (def.parameterOrdering) {
+    if (!def.parameterOrdering.includes(MODIFY_INTERFACE_OBJECT_PARAMETER)) {
+      def.parameterOrdering.unshift(MODIFY_INTERFACE_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, Object.fromEntries(Object.entries(allProperties).map(([id, prop]) => [id, prop.sharedPropertyType])), 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)]));
+  return defineAction({
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Modify ${def.interfaceType.displayMetadata.displayName}`,
+    parameters,
+    status: def.status ?? (def.interfaceType.status.type !== "deprecated" ? def.interfaceType.status.type : def.interfaceType.status),
+    entities: {
+      affectedInterfaceTypes: [def.interfaceType.apiName],
+      affectedObjectTypes: [],
+      affectedLinkTypes: [],
+      typeGroups: []
+    },
+    rules: [{
+      type: "modifyInterfaceRule",
+      modifyInterfaceRule: {
+        interfaceObjectToModifyParameter: "interfaceObjectToModifyParameter",
+        sharedPropertyValues: {
+          ...Object.fromEntries(propertyParameters.map((id) => [id, {
+            type: "parameterId",
+            parameterId: id
+          }])),
+          ...mappings
+        }
+      }
+    }],
+    parameterOrdering: def.parameterOrdering ?? createDefaultParameterOrdering(def, Object.keys(allProperties), parameters, MODIFY_INTERFACE_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...def.enableLayoutSwitch && {
+      enableLayoutSwitch: def.enableLayoutSwitch
+    },
+    ...def.sections && {
+      sections: Object.fromEntries(def.sections.map((section) => [section.id, section]))
+    },
+    ...def.submissionMetadata && {
+      submissionMetadata: def.submissionMetadata
+    }
+  });
+}
+
+// src/api/defineModifyObjectAction.ts
+function defineModifyObjectAction(def) {
+  validateActionParameters(def, Object.keys(def.objectType.properties ?? {}), def.objectType.apiName);
+  const propertyParameters = Object.keys(def.objectType.properties ?? {}).filter((id) => isPropertyParameter(def, id, 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.unshift(MODIFY_OBJECT_PARAMETER);
+    }
+    validateParameterOrdering(def.parameterOrdering, parameterNames, actionApiName);
+  }
+  const parameters = createParameters(def, def.objectType.properties ?? {}, parameterNames);
+  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: actionApiName,
+    displayName: def.displayName ?? `Modify ${def.objectType.displayName}`,
+    parameters,
+    status: def.status ?? "active",
+    rules: [{
+      type: "modifyObjectRule",
+      modifyObjectRule: {
+        objectToModify: 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, Object.keys(def.objectType.properties ?? {}), parameters, MODIFY_OBJECT_PARAMETER),
+    ...def.actionLevelValidation ? {
+      validation: convertValidationRule(def.actionLevelValidation, parameters)
+    } : {},
+    ...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 convertValueTypeTypeToBaseType(valueType) {
   switch (true) {
     case (typeof valueType === "object" && valueType.type === "array"):
@@ -3039,7 +3120,9 @@ function wrapWithProxy(entity) {
   });
 }
 
+exports.CREATE_INTERFACE_OBJECT_PARAMETER = CREATE_INTERFACE_OBJECT_PARAMETER;
 exports.CREATE_OR_MODIFY_OBJECT_PARAMETER = CREATE_OR_MODIFY_OBJECT_PARAMETER;
+exports.MODIFY_INTERFACE_OBJECT_PARAMETER = MODIFY_INTERFACE_OBJECT_PARAMETER;
 exports.MODIFY_OBJECT_PARAMETER = MODIFY_OBJECT_PARAMETER;
 exports.OntologyEntityTypeEnum = OntologyEntityTypeEnum;
 exports.addDependency = addDependency;