@osdk/maker 0.12.0-beta.8 → 0.12.0-rc.23

package/build/esm/api/defineAction.js

@@ -16,10 +16,10 @@
 
 import { consola } from "consola";
 import invariant from "tiny-invariant";
-import { getAllInterfaceProperties } from "./defineObject.js";
+import { convertToDisplayName, getAllInterfaceProperties } from "./defineObject.js";
 import { namespace, ontologyDefinition, updateOntology } from "./defineOntology.js";
-import { convertConditionDefinition } from "./ontologyUtils.js";
-import { OntologyEntityTypeEnum } from "./types.js";
+import { convertConditionDefinition, convertMappingValue } from "./ontologyUtils.js";
+import { CREATE_OR_MODIFY_OBJECT_PARAMETER, MODIFY_OBJECT_PARAMETER, OntologyEntityTypeEnum } from "./types.js";
 export function defineCreateInterfaceObjectAction(interfaceType, objectType, validation) {
   const allProperties = Object.entries(getAllInterfaceProperties(interfaceType)).filter(([_, prop]) => !isStruct(prop.sharedPropertyType.type));
   if (allProperties.length !== Object.entries(getAllInterfaceProperties(interfaceType)).length) {
@@ -64,7 +64,7 @@ export function defineCreateInterfaceObjectAction(interfaceType, objectType, val
         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,
@@ -90,49 +90,61 @@ export function defineCreateInterfaceObjectAction(interfaceType, objectType, val
     } : {})
   });
 }
-export function defineCreateObjectAction(objectType, validation) {
-  const filteredProperties = objectType.properties?.filter(prop => !isStruct(prop.type)) ?? [];
-  if (filteredProperties.length !== (objectType.properties?.length ?? 0)) {
-    consola.info(`Some properties on ${objectType.apiName} were skipped in the create action because they are structs`);
+export 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, true);
+  const mappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [id, convertMappingValue(value)]));
   return defineAction({
-    apiName: `create-object-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`,
-    displayName: `Create ${objectType.displayName}`,
-    parameters: [...filteredProperties.map(prop => ({
-      id: prop.apiName,
-      displayName: prop.displayName,
-      type: extractActionParameterType(prop),
-      typeClasses: prop.typeClasses ?? [],
-      validation: {
-        required: prop.array ?? false ? {
-          listLength: prop.nullability?.noEmptyCollections ? {
-            min: 1
-          } : {}
-        } : prop.nullability?.noNulls ?? true,
-        allowedValues: extractAllowedValuesFromType(prop.type)
-      }
-    }))],
-    status: "active",
+    apiName: actionApiName,
+    displayName: def.displayName ?? `Create ${def.objectType.displayName}`,
+    parameters: parameters,
+    status: def.status ?? "active",
     entities: {
       affectedInterfaceTypes: [],
-      affectedObjectTypes: [objectType.apiName],
+      affectedObjectTypes: [def.objectType.apiName],
       affectedLinkTypes: [],
       typeGroups: []
     },
     rules: [{
       type: "addObjectRule",
       addObjectRule: {
-        objectTypeId: objectType.apiName,
-        propertyValues: filteredProperties.length > 0 ? Object.fromEntries(filteredProperties.map(p => [p.apiName, {
-          type: "parameterId",
-          parameterId: p.apiName
-        }])) : {},
+        objectTypeId: def.objectType.apiName,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map(p => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
         structFieldValues: {}
       }
     }],
-    ...(validation ? {
-      validation: [convertValidationRule(validation)]
-    } : {})
+    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
+    })
   });
 }
 export function defineModifyInterfaceObjectAction(interfaceType, objectType, validation) {
@@ -178,7 +190,7 @@ export function defineModifyInterfaceObjectAction(interfaceType, objectType, val
         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,
@@ -203,78 +215,89 @@ export function defineModifyInterfaceObjectAction(interfaceType, objectType, val
     } : {})
   });
 }
-export function defineModifyObjectAction(objectType, validation) {
-  const properties = objectType.properties ?? [];
-  const filteredProperties = properties.filter(prop => !isStruct(prop.type) && prop.apiName !== objectType.primaryKeyPropertyApiName);
-  if (filteredProperties.length < properties.length) {
-    consola.warn(`Some properties on ${objectType.apiName} were skipped in the modify action because they were structs, or were the object's primary key which cannot be edited.`);
+export 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);
   }
-  return defineAction({
-    apiName: `modify-object-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`,
-    displayName: `Modify ${objectType.displayName}`,
-    parameters: [{
-      id: "objectToModifyParameter",
-      displayName: "Modify object",
-      type: {
-        type: "objectReference",
-        objectReference: {
-          objectTypeId: objectType.apiName
+  const parameters = createParameters(def, parameterNames, false);
+  parameters.forEach(p => {
+    if (p.id !== MODIFY_OBJECT_PARAMETER && p.defaultValue === undefined) {
+      p.defaultValue = {
+        type: "objectParameterPropertyValue",
+        objectParameterPropertyValue: {
+          parameterId: MODIFY_OBJECT_PARAMETER,
+          propertyTypeId: p.id
         }
-      },
-      validation: {
-        allowedValues: {
-          type: "objectQuery"
+      };
+    }
+  });
+  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: 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
         },
-        required: true
-      }
-    }, ...filteredProperties.map(prop => ({
-      id: prop.apiName,
-      displayName: prop.displayName,
-      type: extractActionParameterType(prop),
-      typeClasses: prop.typeClasses ?? [],
-      validation: {
-        required: prop.array ?? false ? {
-          listLength: prop.nullability?.noEmptyCollections ? {
-            min: 1
-          } : {}
-        } : prop.nullability?.noNulls ?? false,
-        allowedValues: extractAllowedValuesFromType(prop.type)
+        structFieldValues: {}
       }
-    }))],
-    status: "active",
+    }],
     entities: {
       affectedInterfaceTypes: [],
-      affectedObjectTypes: [objectType.apiName],
+      affectedObjectTypes: [def.objectType.apiName],
       affectedLinkTypes: [],
       typeGroups: []
     },
-    rules: [{
-      type: "modifyObjectRule",
-      modifyObjectRule: {
-        objectToModify: "objectToModifyParameter",
-        propertyValues: filteredProperties.length > 0 ? Object.fromEntries(filteredProperties.map(p => [p.apiName, {
-          type: "parameterId",
-          parameterId: p.apiName
-        }])) : {},
-        structFieldValues: {}
-      }
-    }],
-    ...(validation ? {
-      validation: [convertValidationRule(validation)]
-    } : {})
+    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
+    })
   });
 }
-export function defineDeleteObjectAction(objectType, validation) {
+export function defineDeleteObjectAction(def) {
   return defineAction({
-    apiName: `delete-object-${kebab(objectType.apiName.split(".").pop() ?? objectType.apiName)}`,
-    displayName: `Delete ${objectType.displayName}`,
+    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: objectType.apiName
+          objectTypeId: def.objectType.apiName
         }
       },
       validation: {
@@ -284,22 +307,94 @@ export function defineDeleteObjectAction(objectType, validation) {
         }
       }
     }],
-    status: "active",
+    status: def.status ?? "active",
+    rules: [{
+      type: "deleteObjectRule",
+      deleteObjectRule: {
+        objectToDelete: "objectToDeleteParameter"
+      }
+    }],
     entities: {
       affectedInterfaceTypes: [],
-      affectedObjectTypes: [objectType.apiName],
+      affectedObjectTypes: [def.objectType.apiName],
       affectedLinkTypes: [],
       typeGroups: []
     },
+    ...(def.actionLevelValidation ? {
+      validation: [convertValidationRule(def.actionLevelValidation)]
+    } : {})
+  });
+}
+export 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 === undefined) {
+      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: parameters,
+    status: def.status ?? "active",
     rules: [{
-      type: "deleteObjectRule",
-      deleteObjectRule: {
-        objectToDelete: "objectToDeleteParameter"
+      type: "addOrModifyObjectRuleV2",
+      addOrModifyObjectRuleV2: {
+        objectToModify: CREATE_OR_MODIFY_OBJECT_PARAMETER,
+        propertyValues: {
+          ...Object.fromEntries(propertyParameters.map(p => [p, {
+            type: "parameterId",
+            parameterId: p
+          }])),
+          ...mappings
+        },
+        structFieldValues: {}
       }
     }],
-    ...(validation ? {
-      validation: [convertValidationRule(validation)]
-    } : {})
+    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
+    })
   });
 }
 export function defineAction(actionDef) {
@@ -336,15 +431,90 @@ export 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] !== undefined ? {
+      ...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 = new Set();
 
   // section definitions
-  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));
 
   // form content ordering
   (actionDef.formContentOrdering ?? []).forEach(item => {
@@ -403,7 +573,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 {
@@ -486,6 +729,10 @@ function extractAllowedValuesFromType(type) {
           } : {
             type: "mandatoryMarking"
           };
+        case "string":
+          return {
+            type: "text"
+          };
         case "struct":
           throw new Error("Structs are not supported yet");
         default:
@@ -500,6 +747,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:
@@ -547,16 +796,22 @@ function convertValidationRule(actionValidation) {
     }
   };
 }
-function validateActionValidation(action) {
+function validateActionConfiguration(action) {
   const seenParameterIds = 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;
@@ -567,12 +822,12 @@ function validateActionCondition(condition, currentParameterId, seenParameterIds
     case "and":
       // this will not catch the niche edge case where users use the full syntax for unions
       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":
@@ -587,4 +842,46 @@ 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" ? invariant(false, `Default value for parameter ${currentParameterId} is referencing unknown parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant(false) : void 0;
+      !seenParameterIds.has(defaultValue.objectParameterPropertyValue.parameterId) ? process.env.NODE_ENV !== "production" ? invariant(false, `Default value for parameter ${currentParameterId} is referencing later parameter ${defaultValue.objectParameterPropertyValue.parameterId}`) : invariant(false) : void 0;
+      break;
+    case "staticValue":
+      !(defaultValue.staticValue.type === parameters?.find(p => p.id === currentParameterId)?.type) ? process.env.NODE_ENV !== "production" ? invariant(false, `Default static value for parameter ${currentParameterId} does not match type`) : invariant(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) {
+  // validates that parameters either exist as object properties or have a type defined
+  [...Object.keys(def.parameterConfiguration ?? {})].forEach(id => {
+    !(def.objectType.properties?.[id] !== undefined || def.parameterConfiguration?.[id].customParameterType !== undefined || id === MODIFY_OBJECT_PARAMETER || id === CREATE_OR_MODIFY_OBJECT_PARAMETER) ? process.env.NODE_ENV !== "production" ? invariant(false, `Parameter ${id} does not exist as a property on ${def.objectType.apiName} and its type is not explicitly defined`) : invariant(false) : void 0;
+  });
+  [...Object.keys(def.nonParameterMappings ?? {}), ...(def.excludedProperties ?? [])].forEach(id => {
+    !(def.objectType.properties?.[id] !== undefined) ? process.env.NODE_ENV !== "production" ? invariant(false, `Property ${id} does not exist as a property on ${def.objectType.apiName}`) : invariant(false) : void 0;
+  });
+}
+
+// Parameters with configurations will be ordered first in the order they were defined
+// followed by the rest of the parameters in the order they were defined on the object type
+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" ? invariant(false, `Action parameter ordering for ${actionApiName} does not match expected parameters. Extraneous parameters in ordering: {${extraneousParameters}}, Missing parameters in ordering: {${missingParameters}}`) : invariant(false) : void 0;
+}
 //# sourceMappingURL=defineAction.js.map