@party-stack/foundry-ontology 0.18.0 → 0.18.1

package/lib/meta/convertMetaActionType.js

@@ -1,653 +1,530 @@
-import { fromBlueprintIconName } from "@party-stack/icons-blueprint";
-import { Temporal } from "temporal-polyfill";
 import { toOntologyActionTypeName } from "../utils/actionTypeName.js";
-import { convertOmsActionParameterDefaults, convertOmsActionParameterStringConstraint, convertOmsActionParameterStringSuggestions, } from "./convertOmsActionParameterMetadata.js";
+import { convertOmsActionParameterDefaults, convertOmsActionParameterStringConstraint, convertOmsActionParameterStringSuggestions } from "./convertOmsActionParameterMetadata.js";
 import { foundryAttachmentMeta } from "./foundryAttachmentMetadata.js";
+import { Temporal } from "temporal-polyfill";
+import { fromBlueprintIconName } from "@party-stack/icons-blueprint";
+//#region src/meta/convertMetaActionType.ts
 const FOUNDRY_CURRENT_USER_CONTEXT_PATH = ["user"];
 const FOUNDRY_UUID_PARAMETER_PREFIX = "__uuid_";
 const FOUNDRY_NOW_PARAMETER_NAME = "__now";
 const FOUNDRY_LIST_ITEM_BINDING = "item";
 function maybeOptional(type, required) {
-    return required ? type : { kind: "optional", value: { type } };
+	return required ? type : {
+		kind: "optional",
+		value: { type }
+	};
 }
 function stringType(constraint, suggestions) {
-    return {
-        kind: "string",
-        value: {
-            constraint,
-            suggestions,
-        },
-    };
+	return {
+		kind: "string",
+		value: {
+			constraint,
+			suggestions
+		}
+	};
 }
 function applyStringConstraintFallback(type, constraint) {
-    if (!constraint)
-        return type;
-    switch (type.kind) {
-        case "string":
-            return type.value.constraint
-                ? type
-                : {
-                    ...type,
-                    value: {
-                        ...type.value,
-                        constraint,
-                    },
-                };
-        case "optional":
-            return {
-                ...type,
-                value: {
-                    ...type.value,
-                    type: applyStringConstraintFallback(type.value.type, constraint),
-                },
-            };
-        case "list":
-            return {
-                ...type,
-                value: {
-                    ...type.value,
-                    elementType: applyStringConstraintFallback(type.value.elementType, constraint),
-                },
-            };
-        default:
-            return type;
-    }
+	if (!constraint) return type;
+	switch (type.kind) {
+		case "string": return type.value.constraint ? type : {
+			...type,
+			value: {
+				...type.value,
+				constraint
+			}
+		};
+		case "optional": return {
+			...type,
+			value: {
+				...type.value,
+				type: applyStringConstraintFallback(type.value.type, constraint)
+			}
+		};
+		case "list": return {
+			...type,
+			value: {
+				...type.value,
+				elementType: applyStringConstraintFallback(type.value.elementType, constraint)
+			}
+		};
+		default: return type;
+	}
 }
 function applyStringSuggestionsFallback(type, suggestions) {
-    if (!suggestions)
-        return type;
-    switch (type.kind) {
-        case "string":
-            return type.value.suggestions
-                ? type
-                : {
-                    ...type,
-                    value: {
-                        ...type.value,
-                        suggestions,
-                    },
-                };
-        case "optional":
-            return {
-                ...type,
-                value: {
-                    ...type.value,
-                    type: applyStringSuggestionsFallback(type.value.type, suggestions),
-                },
-            };
-        case "list":
-            return {
-                ...type,
-                value: {
-                    ...type.value,
-                    elementType: applyStringSuggestionsFallback(type.value.elementType, suggestions),
-                },
-            };
-        default:
-            return type;
-    }
+	if (!suggestions) return type;
+	switch (type.kind) {
+		case "string": return type.value.suggestions ? type : {
+			...type,
+			value: {
+				...type.value,
+				suggestions
+			}
+		};
+		case "optional": return {
+			...type,
+			value: {
+				...type.value,
+				type: applyStringSuggestionsFallback(type.value.type, suggestions)
+			}
+		};
+		case "list": return {
+			...type,
+			value: {
+				...type.value,
+				elementType: applyStringSuggestionsFallback(type.value.elementType, suggestions)
+			}
+		};
+		default: return type;
+	}
 }
 function applyOmsStructFieldValidation(type, omsMetadata, parameterName) {
-    if (!omsMetadata)
-        return type;
-    switch (type.kind) {
-        case "optional":
-            return {
-                ...type,
-                value: {
-                    ...type.value,
-                    type: applyOmsStructFieldValidation(type.value.type, omsMetadata, parameterName),
-                },
-            };
-        case "list":
-            return {
-                ...type,
-                value: {
-                    ...type.value,
-                    elementType: applyOmsStructFieldValidation(type.value.elementType, omsMetadata, parameterName),
-                },
-            };
-        case "struct":
-            return {
-                ...type,
-                value: {
-                    ...type.value,
-                    fields: type.value.fields.map((field) => ({
-                        ...field,
-                        type: applyStringSuggestionsFallback(applyStringConstraintFallback(field.type, convertOmsActionParameterStringConstraint(omsMetadata, parameterName, field.name)), convertOmsActionParameterStringSuggestions(omsMetadata, parameterName, field.name)),
-                    })),
-                },
-            };
-        default:
-            return type;
-    }
+	if (!omsMetadata) return type;
+	switch (type.kind) {
+		case "optional": return {
+			...type,
+			value: {
+				...type.value,
+				type: applyOmsStructFieldValidation(type.value.type, omsMetadata, parameterName)
+			}
+		};
+		case "list": return {
+			...type,
+			value: {
+				...type.value,
+				elementType: applyOmsStructFieldValidation(type.value.elementType, omsMetadata, parameterName)
+			}
+		};
+		case "struct": return {
+			...type,
+			value: {
+				...type.value,
+				fields: type.value.fields.map((field) => ({
+					...field,
+					type: applyStringSuggestionsFallback(applyStringConstraintFallback(field.type, convertOmsActionParameterStringConstraint(omsMetadata, parameterName, field.name)), convertOmsActionParameterStringSuggestions(omsMetadata, parameterName, field.name))
+				}))
+			}
+		};
+		default: return type;
+	}
 }
 function booleanType() {
-    return { kind: "boolean", value: {} };
+	return {
+		kind: "boolean",
+		value: {}
+	};
 }
 function integerType() {
-    return { kind: "integer", value: {} };
+	return {
+		kind: "integer",
+		value: {}
+	};
 }
 function floatType() {
-    return { kind: "float", value: {} };
+	return {
+		kind: "float",
+		value: {}
+	};
 }
 function doubleType() {
-    return { kind: "double", value: {} };
+	return {
+		kind: "double",
+		value: {}
+	};
 }
 function dateType() {
-    return { kind: "date", value: {} };
+	return {
+		kind: "date",
+		value: {}
+	};
 }
 function timestampType() {
-    return { kind: "timestamp", value: {} };
+	return {
+		kind: "timestamp",
+		value: {}
+	};
 }
 function geopointType() {
-    return { kind: "geopoint", value: {} };
+	return {
+		kind: "geopoint",
+		value: {}
+	};
 }
 function attachmentType(type) {
-    return {
-        kind: "attachment",
-        value: { meta: foundryAttachmentMeta(type) },
-    };
+	return {
+		kind: "attachment",
+		value: { meta: foundryAttachmentMeta(type) }
+	};
 }
 function createUniqueIdentifierParameterName(linkId) {
-    return `${FOUNDRY_UUID_PARAMETER_PREFIX}${encodeURIComponent(linkId)}`;
+	return `${FOUNDRY_UUID_PARAMETER_PREFIX}${encodeURIComponent(linkId)}`;
 }
 function getUniqueIdentifierLinkIdFromParameterName(parameterName) {
-    if (!parameterName.startsWith(FOUNDRY_UUID_PARAMETER_PREFIX)) {
-        return undefined;
-    }
-    return decodeURIComponent(parameterName.slice(FOUNDRY_UUID_PARAMETER_PREFIX.length));
+	if (!parameterName.startsWith(FOUNDRY_UUID_PARAMETER_PREFIX)) return;
+	return decodeURIComponent(parameterName.slice(7));
 }
 function convertActionParameterType(type, required = true, validation) {
-    const allowedValues = validation?.defaultValidation.allowedValues;
-    if (allowedValues?.type === "valueType") {
-        return maybeOptional({
-            kind: "ref",
-            value: { name: allowedValues.apiName },
-        }, required);
-    }
-    const baseType = (() => {
-        switch (type.type) {
-            case "string":
-                // TODO: Convert Foundry "user input" parameters to a principal
-                // reference once Ontologies V2 exposes that setting in action
-                // metadata. It currently returns an unconstrained string.
-                // https://valinor-enterprises.slack.com/archives/C08549X3VDM/p1787718253341589
-                return stringType(convertActionParameterStringConstraint(validation), convertActionParameterStringSuggestions(validation));
-            case "boolean":
-                return booleanType();
-            case "integer":
-            case "long":
-                return integerType();
-            case "double":
-                return doubleType();
-            case "decimal":
-                // Preserve the exact value until Party Stack has a decimal
-                // type with explicit precision and scale.
-                return stringType();
-            case "date":
-                return dateType();
-            case "timestamp":
-                return timestampType();
-            case "attachment":
-                return attachmentType("attachment");
-            case "mediaReference":
-                return attachmentType("media");
-            case "geohash":
-                return geopointType();
-            case "geoshape":
-            case "marking":
-                return stringType();
-            case "vector":
-                return {
-                    kind: "list",
-                    value: { elementType: doubleType() },
-                };
-            case "array":
-                return {
-                    kind: "list",
-                    value: { elementType: convertActionParameterType(type.subType) },
-                };
-            case "struct":
-                return {
-                    kind: "struct",
-                    value: {
-                        fields: type.fields.map((field, index) => ({
-                            name: field.name ?? `field${index + 1}`,
-                            displayName: field.name ?? `Field ${index + 1}`,
-                            type: convertOntologyDataType(field.fieldType, field.required),
-                        })),
-                    },
-                };
-            case "object":
-                return {
-                    kind: "objectReference",
-                    value: { objectType: type.objectTypeApiName },
-                };
-            case "objectType":
-            case "interfaceObject":
-            case "objectSet":
-            case "scenarioReference":
-                return stringType();
-            default: {
-                const unsupported = type;
-                return unsupported;
-            }
-        }
-    })();
-    return maybeOptional(baseType, required);
+	const allowedValues = validation?.defaultValidation.allowedValues;
+	if (allowedValues?.type === "valueType") return maybeOptional({
+		kind: "ref",
+		value: { name: allowedValues.apiName }
+	}, required);
+	return maybeOptional((() => {
+		switch (type.type) {
+			case "string": return stringType(convertActionParameterStringConstraint(validation), convertActionParameterStringSuggestions(validation));
+			case "boolean": return booleanType();
+			case "integer":
+			case "long": return integerType();
+			case "double": return doubleType();
+			case "decimal": return stringType();
+			case "date": return dateType();
+			case "timestamp": return timestampType();
+			case "attachment": return attachmentType("attachment");
+			case "mediaReference": return attachmentType("media");
+			case "geohash": return geopointType();
+			case "geoshape":
+			case "marking": return stringType();
+			case "vector": return {
+				kind: "list",
+				value: { elementType: doubleType() }
+			};
+			case "array": return {
+				kind: "list",
+				value: { elementType: convertActionParameterType(type.subType) }
+			};
+			case "struct": return {
+				kind: "struct",
+				value: { fields: type.fields.map((field, index) => ({
+					name: field.name ?? `field${index + 1}`,
+					displayName: field.name ?? `Field ${index + 1}`,
+					type: convertOntologyDataType(field.fieldType, field.required)
+				})) }
+			};
+			case "object": return {
+				kind: "objectReference",
+				value: { objectType: type.objectTypeApiName }
+			};
+			case "objectType":
+			case "interfaceObject":
+			case "objectSet":
+			case "scenarioReference": return stringType();
+			default: return type;
+		}
+	})(), required);
 }
 function convertActionParameterStringConstraint(validation) {
-    const allowedValues = validation?.defaultValidation.allowedValues;
-    if (allowedValues?.type === "oneOf" && !allowedValues.otherValuesAllowed) {
-        const options = allowedValues.options.flatMap((option) => {
-            const value = option.value;
-            return typeof value === "string" ? [{ value, label: option.displayName }] : [];
-        });
-        return options.length > 0
-            ? {
-                kind: "enum",
-                value: { options },
-            }
-            : undefined;
-    }
-    if (allowedValues?.type === "text" && allowedValues.regex) {
-        return {
-            kind: "regex",
-            value: { regex: allowedValues.regex },
-        };
-    }
-    return undefined;
+	const allowedValues = validation?.defaultValidation.allowedValues;
+	if (allowedValues?.type === "oneOf" && !allowedValues.otherValuesAllowed) {
+		const options = allowedValues.options.flatMap((option) => {
+			const value = option.value;
+			return typeof value === "string" ? [{
+				value,
+				label: option.displayName
+			}] : [];
+		});
+		return options.length > 0 ? {
+			kind: "enum",
+			value: { options }
+		} : void 0;
+	}
+	if (allowedValues?.type === "text" && allowedValues.regex) return {
+		kind: "regex",
+		value: { regex: allowedValues.regex }
+	};
 }
 function convertActionParameterStringSuggestions(validation) {
-    const allowedValues = validation?.defaultValidation.allowedValues;
-    if (allowedValues?.type !== "oneOf" || !allowedValues.otherValuesAllowed) {
-        return undefined;
-    }
-    const suggestions = allowedValues.options.flatMap((option) => {
-        const value = option.value;
-        return typeof value === "string"
-            ? [
-                {
-                    value,
-                    label: option.displayName,
-                },
-            ]
-            : [];
-    });
-    return suggestions.length > 0 ? suggestions : undefined;
+	const allowedValues = validation?.defaultValidation.allowedValues;
+	if (allowedValues?.type !== "oneOf" || !allowedValues.otherValuesAllowed) return;
+	const suggestions = allowedValues.options.flatMap((option) => {
+		const value = option.value;
+		return typeof value === "string" ? [{
+			value,
+			label: option.displayName
+		}] : [];
+	});
+	return suggestions.length > 0 ? suggestions : void 0;
 }
 function convertOntologyDataType(type, required = true) {
-    const baseType = (() => {
-        switch (type.type) {
-            case "string":
-                return stringType();
-            case "boolean":
-                return booleanType();
-            case "byte":
-            case "short":
-            case "integer":
-            case "long":
-                return integerType();
-            case "float":
-                return floatType();
-            case "double":
-            case "decimal":
-                return doubleType();
-            case "date":
-                return dateType();
-            case "timestamp":
-                return timestampType();
-            case "binary":
-                return attachmentType("attachment");
-            case "mediaReference":
-                return attachmentType("media");
-            case "array":
-            case "set":
-                return {
-                    kind: "list",
-                    value: { elementType: convertOntologyDataType(type.itemType) },
-                };
-            case "struct":
-                return {
-                    kind: "struct",
-                    value: {
-                        fields: type.fields.map((field, index) => ({
-                            name: field.name ?? `field${index + 1}`,
-                            displayName: field.name ?? `Field ${index + 1}`,
-                            type: convertOntologyDataType(field.fieldType, field.required),
-                        })),
-                    },
-                };
-            case "object":
-                return {
-                    kind: "objectReference",
-                    value: { objectType: type.objectTypeApiName },
-                };
-            default:
-                return stringType();
-        }
-    })();
-    return maybeOptional(baseType, required);
+	return maybeOptional((() => {
+		switch (type.type) {
+			case "string": return stringType();
+			case "boolean": return booleanType();
+			case "byte":
+			case "short":
+			case "integer":
+			case "long": return integerType();
+			case "float": return floatType();
+			case "double":
+			case "decimal": return doubleType();
+			case "date": return dateType();
+			case "timestamp": return timestampType();
+			case "binary": return attachmentType("attachment");
+			case "mediaReference": return attachmentType("media");
+			case "array":
+			case "set": return {
+				kind: "list",
+				value: { elementType: convertOntologyDataType(type.itemType) }
+			};
+			case "struct": return {
+				kind: "struct",
+				value: { fields: type.fields.map((field, index) => ({
+					name: field.name ?? `field${index + 1}`,
+					displayName: field.name ?? `Field ${index + 1}`,
+					type: convertOntologyDataType(field.fieldType, field.required)
+				})) }
+			};
+			case "object": return {
+				kind: "objectReference",
+				value: { objectType: type.objectTypeApiName }
+			};
+			default: return stringType();
+		}
+	})(), required);
 }
 function collectRuleArguments(rule) {
-    switch (rule.type) {
-        case "createObject":
-        case "modifyObject":
-            return [
-                ...Object.values(rule.propertyArguments),
-                ...Object.values(rule.structPropertyArguments).flatMap((fields) => Object.values(fields)),
-            ];
-        default:
-            return [];
-    }
+	switch (rule.type) {
+		case "createObject":
+		case "modifyObject": return [...Object.values(rule.propertyArguments), ...Object.values(rule.structPropertyArguments).flatMap((fields) => Object.values(fields))];
+		default: return [];
+	}
 }
 function collectMutationTargetParameterNames(rules) {
-    const parameterNames = new Set();
-    for (const rule of rules) {
-        switch (rule.type) {
-            case "modifyObject":
-                parameterNames.add(rule.objectToModify);
-                break;
-            case "deleteObject":
-                parameterNames.add(rule.objectToDelete);
-                break;
-        }
-    }
-    return parameterNames;
+	const parameterNames = /* @__PURE__ */ new Set();
+	for (const rule of rules) switch (rule.type) {
+		case "modifyObject":
+			parameterNames.add(rule.objectToModify);
+			break;
+		case "deleteObject": parameterNames.add(rule.objectToDelete);
+	}
+	return parameterNames;
 }
 function requireObjectReferenceMutationTarget(type, isMutationTarget) {
-    return isMutationTarget && type.kind === "optional" && type.value.type.kind === "objectReference"
-        ? type.value.type
-        : type;
+	return isMutationTarget && type.kind === "optional" && type.value.type.kind === "objectReference" ? type.value.type : type;
 }
 function createSyntheticParameters(actionType) {
-    const uniqueIdentifierParametersByLinkId = new Map();
-    let nowParameterName;
-    for (const rule of actionType.fullLogicRules) {
-        for (const argument of collectRuleArguments(rule)) {
-            if (argument.type === "uniqueIdentifier" && argument.linkId) {
-                if (!uniqueIdentifierParametersByLinkId.has(argument.linkId)) {
-                    uniqueIdentifierParametersByLinkId.set(argument.linkId, createUniqueIdentifierParameterName(argument.linkId));
-                }
-            }
-            if (argument.type === "currentTime" && !nowParameterName) {
-                nowParameterName = FOUNDRY_NOW_PARAMETER_NAME;
-            }
-        }
-    }
-    const parameters = Array.from(uniqueIdentifierParametersByLinkId.values()).map((name, index) => ({
-        name,
-        displayName: `Generated UUID ${index + 1}`,
-        type: { kind: "string", value: {} },
-        defaultValue: {
-            kind: "uuid",
-            value: {},
-        },
-    }));
-    if (nowParameterName) {
-        parameters.push({
-            name: nowParameterName,
-            displayName: "Current time",
-            type: { kind: "timestamp", value: {} },
-            defaultValue: {
-                kind: "now",
-                value: {},
-            },
-        });
-    }
-    return { parameters, uniqueIdentifierParametersByLinkId, nowParameterName };
-}
-export function getFoundryActionOverrideParameterMapping(actionType) {
-    const uuidByParameterName = new Map();
-    let nowParameterName;
-    for (const parameter of actionType.parameters) {
-        if (parameter.defaultValue?.kind !== "uuid" && parameter.defaultValue?.kind !== "now") {
-            continue;
-        }
-        switch (parameter.defaultValue.kind) {
-            case "uuid": {
-                const linkId = getUniqueIdentifierLinkIdFromParameterName(parameter.name);
-                if (linkId) {
-                    uuidByParameterName.set(parameter.name, linkId);
-                }
-                break;
-            }
-            case "now":
-                nowParameterName ??= parameter.name;
-                break;
-        }
-    }
-    return { uuidByParameterName, nowParameterName };
+	const uniqueIdentifierParametersByLinkId = /* @__PURE__ */ new Map();
+	let nowParameterName;
+	for (const rule of actionType.fullLogicRules) for (const argument of collectRuleArguments(rule)) {
+		if (argument.type === "uniqueIdentifier" && argument.linkId) {
+			if (!uniqueIdentifierParametersByLinkId.has(argument.linkId)) uniqueIdentifierParametersByLinkId.set(argument.linkId, createUniqueIdentifierParameterName(argument.linkId));
+		}
+		if (argument.type === "currentTime" && !nowParameterName) nowParameterName = FOUNDRY_NOW_PARAMETER_NAME;
+	}
+	const parameters = Array.from(uniqueIdentifierParametersByLinkId.values()).map((name, index) => ({
+		name,
+		displayName: `Generated UUID ${index + 1}`,
+		type: {
+			kind: "string",
+			value: {}
+		},
+		defaultValue: {
+			kind: "uuid",
+			value: {}
+		}
+	}));
+	if (nowParameterName) parameters.push({
+		name: nowParameterName,
+		displayName: "Current time",
+		type: {
+			kind: "timestamp",
+			value: {}
+		},
+		defaultValue: {
+			kind: "now",
+			value: {}
+		}
+	});
+	return {
+		parameters,
+		uniqueIdentifierParametersByLinkId,
+		nowParameterName
+	};
+}
+function getFoundryActionOverrideParameterMapping(actionType) {
+	const uuidByParameterName = /* @__PURE__ */ new Map();
+	let nowParameterName;
+	for (const parameter of actionType.parameters) {
+		if (parameter.defaultValue?.kind !== "uuid" && parameter.defaultValue?.kind !== "now") continue;
+		switch (parameter.defaultValue.kind) {
+			case "uuid": {
+				const linkId = getUniqueIdentifierLinkIdFromParameterName(parameter.name);
+				if (linkId) uuidByParameterName.set(parameter.name, linkId);
+				break;
+			}
+			case "now": nowParameterName ??= parameter.name;
+		}
+	}
+	return {
+		uuidByParameterName,
+		nowParameterName
+	};
 }
 function inputReference(name) {
-    return {
-        kind: "inputReference",
-        value: { name },
-    };
+	return {
+		kind: "inputReference",
+		value: { name }
+	};
 }
 function getAtExpression(source, path) {
-    return {
-        kind: "getAt",
-        value: { source, path },
-    };
+	return {
+		kind: "getAt",
+		value: {
+			source,
+			path
+		}
+	};
 }
 function objectField(parameterName, path) {
-    return getAtExpression({
-        kind: "objectLookup",
-        value: {
-            reference: inputReference(parameterName),
-        },
-    }, path);
-}
-// TODO: This uses regex heuristics to infer the type of static literal values without
-// knowing the target property type. We should eventually resolve the target property's
-// TypeDef from the object type definition so we decode accurately instead of guessing
-// from the string format.
+	return getAtExpression({
+		kind: "objectLookup",
+		value: { reference: inputReference(parameterName) }
+	}, path);
+}
 const ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
 const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
 const GEO_POINT_RE = /^(-?\d+(?:\.\d+)?),\s*(-?\d+(?:\.\d+)?)$/;
 function decodeLiteralValue(value) {
-    if (typeof value !== "string") {
-        return value;
-    }
-    if (ISO_TIMESTAMP_RE.test(value)) {
-        try {
-            return Temporal.Instant.from(value);
-        }
-        catch {
-            return value;
-        }
-    }
-    if (ISO_DATE_RE.test(value)) {
-        try {
-            return Temporal.PlainDate.from(value);
-        }
-        catch {
-            return value;
-        }
-    }
-    const geoMatch = GEO_POINT_RE.exec(value);
-    if (geoMatch) {
-        return { lat: Number(geoMatch[1]), lon: Number(geoMatch[2]) };
-    }
-    return value;
+	if (typeof value !== "string") return value;
+	if (ISO_TIMESTAMP_RE.test(value)) try {
+		return Temporal.Instant.from(value);
+	} catch {
+		return value;
+	}
+	if (ISO_DATE_RE.test(value)) try {
+		return Temporal.PlainDate.from(value);
+	} catch {
+		return value;
+	}
+	const geoMatch = GEO_POINT_RE.exec(value);
+	if (geoMatch) return {
+		lat: Number(geoMatch[1]),
+		lon: Number(geoMatch[2])
+	};
+	return value;
 }
 function convertLogicRuleArgument(argument, syntheticParameters) {
-    switch (argument.type) {
-        case "parameterId":
-            return inputReference(argument.parameterId);
-        case "objectParameterPropertyValue":
-            return objectField(argument.parameterId, [argument.propertyTypeApiName]);
-        case "structParameterFieldValue":
-            return getAtExpression(inputReference(argument.parameterId), [
-                argument.structParameterFieldApiName,
-            ]);
-        case "structListParameterFieldValue":
-            throw new Error("Foundry list-of-struct field arguments must be converted as a list mapping.");
-        case "uniqueIdentifier": {
-            const parameterName = argument.linkId
-                ? syntheticParameters.uniqueIdentifierParametersByLinkId.get(argument.linkId)
-                : undefined;
-            return parameterName
-                ? inputReference(parameterName)
-                : {
-                    kind: "uuid",
-                    value: {},
-                };
-        }
-        case "currentTime":
-            return syntheticParameters.nowParameterName
-                ? inputReference(syntheticParameters.nowParameterName)
-                : {
-                    kind: "now",
-                    value: {},
-                };
-        case "staticValue":
-            return {
-                kind: "literal",
-                value: { value: decodeLiteralValue(argument.value) },
-            };
-        case "currentUser":
-            return {
-                kind: "contextReference",
-                value: { name: FOUNDRY_CURRENT_USER_CONTEXT_PATH[0] },
-            };
-        default:
-            throw new Error(`Unsupported Foundry action argument "${argument.type}".`);
-    }
+	switch (argument.type) {
+		case "parameterId": return inputReference(argument.parameterId);
+		case "objectParameterPropertyValue": return objectField(argument.parameterId, [argument.propertyTypeApiName]);
+		case "structParameterFieldValue": return getAtExpression(inputReference(argument.parameterId), [argument.structParameterFieldApiName]);
+		case "structListParameterFieldValue": throw new Error("Foundry list-of-struct field arguments must be converted as a list mapping.");
+		case "uniqueIdentifier": {
+			const parameterName = argument.linkId ? syntheticParameters.uniqueIdentifierParametersByLinkId.get(argument.linkId) : void 0;
+			return parameterName ? inputReference(parameterName) : {
+				kind: "uuid",
+				value: {}
+			};
+		}
+		case "currentTime": return syntheticParameters.nowParameterName ? inputReference(syntheticParameters.nowParameterName) : {
+			kind: "now",
+			value: {}
+		};
+		case "staticValue": return {
+			kind: "literal",
+			value: { value: decodeLiteralValue(argument.value) }
+		};
+		case "currentUser": return {
+			kind: "contextReference",
+			value: { name: FOUNDRY_CURRENT_USER_CONTEXT_PATH[0] }
+		};
+		default: throw new Error(`Unsupported Foundry action argument "${argument.type}".`);
+	}
 }
 function convertAssignments(rule, parameters, syntheticParameters) {
-    return [
-        ...Object.entries(rule.propertyArguments).map(([property, argument]) => ({
-            property: [property],
-            value: convertLogicRuleArgument(argument, syntheticParameters),
-        })),
-        ...Object.entries(rule.structPropertyArguments).flatMap(([property, fields]) => convertStructPropertyAssignments(property, fields, parameters, syntheticParameters)),
-    ];
+	return [...Object.entries(rule.propertyArguments).map(([property, argument]) => ({
+		property: [property],
+		value: convertLogicRuleArgument(argument, syntheticParameters)
+	})), ...Object.entries(rule.structPropertyArguments).flatMap(([property, fields]) => convertStructPropertyAssignments(property, fields, parameters, syntheticParameters))];
 }
 function unsupportedListStructAssignment(property, reason) {
-    throw new Error(`Unsupported Foundry list-of-struct assignment for property "${property}": ${reason}. ` +
-        "Party Stack only supports mappings driven by one list-of-struct parameter.");
+	throw new Error(`Unsupported Foundry list-of-struct assignment for property "${property}": ${reason}. Party Stack only supports mappings driven by one list-of-struct parameter.`);
 }
 function convertStructPropertyAssignments(property, fields, parameters, syntheticParameters) {
-    const entries = Object.entries(fields);
-    const listEntries = entries.filter((entry) => entry[1].type === "structListParameterFieldValue");
-    if (listEntries.length === 0) {
-        return entries.map(([field, argument]) => ({
-            property: [property, field],
-            value: convertLogicRuleArgument(argument, syntheticParameters),
-        }));
-    }
-    if (listEntries.length !== entries.length) {
-        return unsupportedListStructAssignment(property, "list fields are mixed with non-list struct field arguments");
-    }
-    const parameterIds = new Set(listEntries.map(([, argument]) => argument.parameterId));
-    if (parameterIds.size !== 1) {
-        return unsupportedListStructAssignment(property, "fields are mapped from multiple list parameters");
-    }
-    const parameterId = listEntries[0][1].parameterId;
-    const parameter = parameters[parameterId];
-    if (parameter?.dataType.type !== "array" || parameter.dataType.subType.type !== "struct") {
-        return unsupportedListStructAssignment(property, `source parameter "${parameterId}" is not a list of structs`);
-    }
-    return [
-        {
-            property: [property],
-            value: {
-                kind: "map",
-                value: {
-                    source: inputReference(parameterId),
-                    binding: FOUNDRY_LIST_ITEM_BINDING,
-                    body: {
-                        kind: "struct",
-                        value: {
-                            fields: entries.map(([field, argument]) => ({
-                                name: field,
-                                value: argument.type === "structListParameterFieldValue"
-                                    ? getAtExpression({
-                                        kind: "localReference",
-                                        value: {
-                                            name: FOUNDRY_LIST_ITEM_BINDING,
-                                        },
-                                    }, [argument.structParameterFieldApiName])
-                                    : convertLogicRuleArgument(argument, syntheticParameters),
-                            })),
-                        },
-                    },
-                },
-            },
-        },
-    ];
+	const entries = Object.entries(fields);
+	const listEntries = entries.filter((entry) => entry[1].type === "structListParameterFieldValue");
+	if (listEntries.length === 0) return entries.map(([field, argument]) => ({
+		property: [property, field],
+		value: convertLogicRuleArgument(argument, syntheticParameters)
+	}));
+	if (listEntries.length !== entries.length) return unsupportedListStructAssignment(property, "list fields are mixed with non-list struct field arguments");
+	if (new Set(listEntries.map(([, argument]) => argument.parameterId)).size !== 1) return unsupportedListStructAssignment(property, "fields are mapped from multiple list parameters");
+	const parameterId = listEntries[0][1].parameterId;
+	const parameter = parameters[parameterId];
+	if (parameter?.dataType.type !== "array" || parameter.dataType.subType.type !== "struct") return unsupportedListStructAssignment(property, `source parameter "${parameterId}" is not a list of structs`);
+	return [{
+		property: [property],
+		value: {
+			kind: "map",
+			value: {
+				source: inputReference(parameterId),
+				binding: FOUNDRY_LIST_ITEM_BINDING,
+				body: {
+					kind: "struct",
+					value: { fields: entries.map(([field, argument]) => ({
+						name: field,
+						value: argument.type === "structListParameterFieldValue" ? getAtExpression({
+							kind: "localReference",
+							value: { name: FOUNDRY_LIST_ITEM_BINDING }
+						}, [argument.structParameterFieldApiName]) : convertLogicRuleArgument(argument, syntheticParameters)
+					})) }
+				}
+			}
+		}
+	}];
 }
 function convertLogicStep(rule, parameters, syntheticParameters) {
-    switch (rule.type) {
-        case "createObject":
-            return {
-                kind: "createObject",
-                value: {
-                    objectType: rule.objectTypeApiName,
-                    values: convertAssignments(rule, parameters, syntheticParameters),
-                },
-            };
-        case "modifyObject":
-            return {
-                kind: "updateObject",
-                value: {
-                    object: {
-                        name: rule.objectToModify,
-                    },
-                    values: convertAssignments(rule, parameters, syntheticParameters),
-                },
-            };
-        case "deleteObject":
-            return {
-                kind: "deleteObject",
-                value: {
-                    object: {
-                        name: rule.objectToDelete,
-                    },
-                },
-            };
-        default:
-            return null;
-    }
-}
-export function convertFoundryMetaActionType(actionType, omsMetadata) {
-    const syntheticParameters = createSyntheticParameters(actionType);
-    const mutationTargetParameterNames = collectMutationTargetParameterNames(actionType.fullLogicRules);
-    const fullLogicRules = actionType.fullLogicRules
-        .map((rule) => convertLogicStep(rule, actionType.actionType.parameters, syntheticParameters))
-        .filter((rule) => rule !== null);
-    const parameters = Object.entries(actionType.actionType.parameters).map(([name, parameter]) => {
-        const type = requireObjectReferenceMutationTarget(convertActionParameterType(parameter.dataType, parameter.required, parameter.validation), mutationTargetParameterNames.has(name));
-        return {
-            name,
-            displayName: parameter.displayName ?? name,
-            type: applyStringSuggestionsFallback(applyStringConstraintFallback(applyOmsStructFieldValidation(type, omsMetadata, name), convertOmsActionParameterStringConstraint(omsMetadata, name)), convertOmsActionParameterStringSuggestions(omsMetadata, name)),
-            description: parameter.description,
-        };
-    });
-    const defaultsByParameter = convertOmsActionParameterDefaults(omsMetadata, parameters);
-    const foundryIcon = omsMetadata?.actionType.metadata?.displayMetadata?.icon;
-    return {
-        id: actionType.actionType.rid,
-        name: toOntologyActionTypeName(actionType.actionType.apiName),
-        displayName: actionType.actionType.displayName ?? actionType.actionType.apiName,
-        description: actionType.actionType.description,
-        icon: foundryIcon?.type === "blueprint"
-            ? fromBlueprintIconName(foundryIcon.blueprint.locator)
-            : undefined,
-        color: foundryIcon?.type === "blueprint" ? foundryIcon.blueprint.color : undefined,
-        deprecated: actionType.actionType.status === "DEPRECATED" ? { message: "Deprecated in Foundry." } : undefined,
-        parameters: [
-            ...parameters.map((parameter) => ({
-                ...parameter,
-                defaultValue: defaultsByParameter.get(parameter.name),
-            })),
-            ...syntheticParameters.parameters,
-        ],
-        logic: fullLogicRules,
-    };
-}
+	switch (rule.type) {
+		case "createObject": return {
+			kind: "createObject",
+			value: {
+				objectType: rule.objectTypeApiName,
+				values: convertAssignments(rule, parameters, syntheticParameters)
+			}
+		};
+		case "modifyObject": return {
+			kind: "updateObject",
+			value: {
+				object: { name: rule.objectToModify },
+				values: convertAssignments(rule, parameters, syntheticParameters)
+			}
+		};
+		case "deleteObject": return {
+			kind: "deleteObject",
+			value: { object: { name: rule.objectToDelete } }
+		};
+		default: return null;
+	}
+}
+function convertFoundryMetaActionType(actionType, omsMetadata) {
+	const syntheticParameters = createSyntheticParameters(actionType);
+	const mutationTargetParameterNames = collectMutationTargetParameterNames(actionType.fullLogicRules);
+	const fullLogicRules = actionType.fullLogicRules.map((rule) => convertLogicStep(rule, actionType.actionType.parameters, syntheticParameters)).filter((rule) => rule !== null);
+	const parameters = Object.entries(actionType.actionType.parameters).map(([name, parameter]) => {
+		const type = requireObjectReferenceMutationTarget(convertActionParameterType(parameter.dataType, parameter.required, parameter.validation), mutationTargetParameterNames.has(name));
+		return {
+			name,
+			displayName: parameter.displayName ?? name,
+			type: applyStringSuggestionsFallback(applyStringConstraintFallback(applyOmsStructFieldValidation(type, omsMetadata, name), convertOmsActionParameterStringConstraint(omsMetadata, name)), convertOmsActionParameterStringSuggestions(omsMetadata, name)),
+			description: parameter.description
+		};
+	});
+	const defaultsByParameter = convertOmsActionParameterDefaults(omsMetadata, parameters);
+	const foundryIcon = omsMetadata?.actionType.metadata?.displayMetadata?.icon;
+	return {
+		id: actionType.actionType.rid,
+		name: toOntologyActionTypeName(actionType.actionType.apiName),
+		displayName: actionType.actionType.displayName ?? actionType.actionType.apiName,
+		description: actionType.actionType.description,
+		icon: foundryIcon?.type === "blueprint" ? fromBlueprintIconName(foundryIcon.blueprint.locator) : void 0,
+		color: foundryIcon?.type === "blueprint" ? foundryIcon.blueprint.color : void 0,
+		deprecated: actionType.actionType.status === "DEPRECATED" ? { message: "Deprecated in Foundry." } : void 0,
+		parameters: [...parameters.map((parameter) => ({
+			...parameter,
+			defaultValue: defaultsByParameter.get(parameter.name)
+		})), ...syntheticParameters.parameters],
+		logic: fullLogicRules
+	};
+}
+//#endregion
+export { convertFoundryMetaActionType, getFoundryActionOverrideParameterMapping };
+
 //# sourceMappingURL=convertMetaActionType.js.map