@osdk/maker 0.14.0-beta.2 → 0.14.0-beta.4

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @osdk/maker
 
+## 0.14.0-beta.4
+
+### Minor Changes
+
+- aca0e5d: Add parameter/property configuration for OAC interface actions
+- 878c2eb: Add display name, api name, status customizations to OAC interface actions
+
+### Patch Changes
+
+- Updated dependencies [84e61fc]
+- Updated dependencies [c4f8529]
+- Updated dependencies [f7ae38a]
+  - @osdk/api@2.6.0-beta.2
+
+## 0.14.0-beta.3
+
+### Minor Changes
+
+- 995064b: Make tests run synchronously
+
 ## 0.14.0-beta.2
 
 ### Minor Changes

package/build/browser/api/defineAction.js

@@ -14,395 +14,18 @@
  * limitations under the License.
  */
 
-import { consola } from "consola";
 import invariant from "tiny-invariant";
 import { convertConditionDefinition } from "../conversion/toMarketplace/convertConditionDefinition.js";
-import { convertMappingValue } from "../conversion/toMarketplace/convertMappingValue.js";
 import { isActionParameterTypePrimitive } from "./action/ActionParameterType.js";
 import { OntologyEntityTypeEnum } from "./common/OntologyEntityTypeEnum.js";
 import { uppercaseFirstLetter } from "./defineObject.js";
-import { importedTypes, namespace, ontologyDefinition, updateOntology } from "./defineOntology.js";
+import { addNamespaceIfNone, importedTypes, namespace, ontologyDefinition, updateOntology } from "./defineOntology.js";
 import { getFlattenedInterfaceProperties } from "./interface/getFlattenedInterfaceProperties.js";
 import { isStruct } from "./properties/PropertyTypeType.js";
 export const MODIFY_OBJECT_PARAMETER = "objectToModifyParameter";
 export const CREATE_OR_MODIFY_OBJECT_PARAMETER = "objectToCreateOrModifyParameter";
-export 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.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 === undefined ? "" : `-${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 === undefined ? {
-          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)
-    } : {})
-  });
-}
-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);
-  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: 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
-    })
-  });
-}
-export 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.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 === undefined ? "" : `-${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 === undefined ? {
-          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)
-    } : {})
-  });
-}
-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);
-  }
-  const parameters = createParameters(def, parameterNames);
-  parameters.forEach(p => {
-    if (p.id !== MODIFY_OBJECT_PARAMETER && p.defaultValue === undefined) {
-      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: 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
-    })
-  });
-}
-export 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)
-    } : {})
-  });
-}
-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);
-  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: "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
-    })
-  });
-}
+export const CREATE_INTERFACE_OBJECT_PARAMETER = "objectTypeParameter";
+export const MODIFY_INTERFACE_OBJECT_PARAMETER = "interfaceObjectToModifyParameter";
 export function defineAction(actionDef) {
   const apiName = namespace + actionDef.apiName;
   const parameterIds = (actionDef.parameters ?? []).map(p => p.id);
@@ -464,11 +87,36 @@ export function defineAction(actionDef) {
   updateOntology(fullAction);
   return fullAction;
 }
-function createParameters(def, parameterSet) {
-  const targetParam = [];
+export function isPropertyParameter(def, name, type) {
+  return !Object.keys(def.nonParameterMappings ?? {}).includes(name) && !isStruct(type) && !def.excludedProperties?.includes(name);
+}
+export 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] !== undefined ? {
+      ...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: {
@@ -490,14 +138,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: {}
             } : {
@@ -518,26 +169,75 @@ function createParameters(def, parameterSet) {
       });
       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 === undefined ? {
+            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 === undefined ? {
+            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(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] !== 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 ?? 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 = new Set();
@@ -804,13 +504,13 @@ function extractActionParameterType(pt) {
 function maybeAddList(type, pt) {
   return pt.array ?? false ? type + "List" : type;
 }
-function kebab(s) {
+export function kebab(s) {
   return s.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").replace(/\./g, "-").toLowerCase();
 }
 function sanitize(s) {
   return s.includes(".") ? s : namespace + s;
 }
-function convertValidationRule(actionValidation, actionParameters) {
+export function convertValidationRule(actionValidation, actionParameters) {
   return actionValidation.map(rule => {
     return {
       condition: convertConditionDefinition(rule.condition, actionParameters),
@@ -888,25 +588,33 @@ function validateParameterPrefill(currentParameterId, seenParameterIds, paramete
       throw new Error(`Unknown default value type for parameter ${currentParameterId}`);
   }
 }
-function validateActionParameters(def) {
+export function validateActionParameters(def, properties, name) {
   // 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;
+    !(properties.includes(id) || properties.includes(addNamespaceIfNone(id)) || def.parameterConfiguration?.[id].customParameterType !== undefined || isTargetParameter(id)) ? process.env.NODE_ENV !== "production" ? invariant(false, `Parameter ${id} does not exist as a property on ${name} 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;
+    !(properties.includes(id) || properties.includes(addNamespaceIfNone(id))) ? process.env.NODE_ENV !== "production" ? invariant(false, `Property ${id} does not exist as a property on ${name}`) : 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))];
+// followed by the rest of the parameters in the order they were defined on the object type.
+export 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) {
+export 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;
 }
+export function isTargetParameter(parameterId) {
+  return parameterId === MODIFY_OBJECT_PARAMETER || parameterId === CREATE_OR_MODIFY_OBJECT_PARAMETER || parameterId === CREATE_INTERFACE_OBJECT_PARAMETER || parameterId === MODIFY_INTERFACE_OBJECT_PARAMETER;
+}
+export function addNamespaceToActionDefinition(def) {
+  def.parameterConfiguration = Object.fromEntries(Object.entries(def.parameterConfiguration ?? {}).map(([id, config]) => [isTargetParameter(id) ? id : addNamespaceIfNone(id), config]));
+  def.nonParameterMappings = Object.fromEntries(Object.entries(def.nonParameterMappings ?? {}).map(([id, value]) => [addNamespaceIfNone(id), value]));
+  def.excludedProperties = def.excludedProperties ?? [].map(id => addNamespaceIfNone(id));
+}
 //# sourceMappingURL=defineAction.js.map