@prismatic-io/spectral 10.18.7 → 10.18.9-preview.0

package/dist/serverTypes/convertIntegration.d.ts

@@ -8,7 +8,7 @@ export declare const convertConfigPages: (pages: ConfigPages | undefined, userLe
 /** Converts typed QueueConfig to legacy format with usesFifoQueue and concurrencyLimit. */
 export declare const convertQueueConfig: (queueConfig: QueueConfig) => StandardQueueConfig;
 /** Converts a Flow into the structure necessary for YAML generation. */
-export declare const convertFlow: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerPerformResult<TAllowsBranching, TPayload> = TriggerPerformResult<TAllowsBranching, TPayload>>(flow: Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>, componentRegistry: ComponentRegistry, referenceKey: string) => Record<string, unknown>;
+export declare const convertFlow: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerPerformResult<TAllowsBranching, TPayload> = TriggerPerformResult<TAllowsBranching, TPayload>>(rawFlow: Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>, componentRegistry: ComponentRegistry, referenceKey: string) => Record<string, unknown>;
 /** Converts an input value to the expected server type by its collection type. */
 export declare const convertInputValue: (value: unknown, collectionType: CollectionType | undefined) => unknown;
 /** Converts a Config Var into the structure necessary for YAML generation. */

package/dist/serverTypes/convertIntegration.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -29,6 +40,46 @@ const integration_1 = require("./integration");
 const perform_1 = require("./perform");
 exports.CONCURRENCY_LIMIT_MAX = 15;
 exports.CONCURRENCY_LIMIT_MIN = 2;
+/**
+ * Default `resolveItems`: a batched `trigger`'s fires return their records under
+ * `payload.body.data` (the wrapper {@link normalizeBatchedFlow} builds writes them there),
+ * so extraction is just reading that array back. Authors never write this themselves.
+ */
+const defaultResolveItems = (_context, result) => result.payload.body.data;
+/**
+ * Expands a flow's batched `trigger` (built with `batchFlowTrigger`) into the flat
+ * `onTrigger`/`onDeployTrigger`/`triggerResolver`/`onDeployResolver` shape the rest of the
+ * conversion pipeline already understands. The trigger fires return just `{ items }`; here we
+ * wrap each into a `TriggerPerformFunction` that emits `{ payload: { …payload, body: { data:
+ * items } } }`, synthesize the default `resolveItems`, and map the pagination callbacks onto
+ * the resolver `getNextDiscoveryState`. Flows without a `trigger` pass through unchanged.
+ *
+ * Returns the same `Flow` type it received; the synthesized `triggerResolver`/`onDeployResolver`
+ * are wire-only fields (not on the author-facing `Flow`), read downstream via `"x" in flow` checks.
+ */
+const normalizeBatchedFlow = (flow) => {
+    const trigger = "trigger" in flow ? flow.trigger : undefined;
+    if (!trigger) {
+        return flow;
+    }
+    const { onTrigger, onDeploy, getNextOnTriggerPaginationState, getNextOnDeployPaginationState } = trigger;
+    // Wrap a batched fire (returns `{ items, response? }`) into a TriggerPerformFunction that
+    // emits the wire payload shape (`body.data = items`), preserving the incoming payload fields.
+    const wrapFire = (fire) => (context, payload) => __awaiter(void 0, void 0, void 0, function* () {
+        const { items, response } = yield fire(context, payload);
+        return Object.assign({ payload: Object.assign(Object.assign({}, payload), { body: { data: items, contentType: "application/json" } }) }, (response ? { response } : {}));
+    });
+    const _a = flow, { trigger: _omitTrigger } = _a, rest = __rest(_a, ["trigger"]);
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, rest), { onTrigger: wrapFire(onTrigger) }), (onDeploy ? { onDeployTrigger: wrapFire(onDeploy) } : {})), { triggerResolver: Object.assign({ resolveItems: defaultResolveItems }, (getNextOnTriggerPaginationState
+            ? { getNextDiscoveryState: getNextOnTriggerPaginationState }
+            : {})) }), (onDeploy
+        ? {
+            onDeployResolver: Object.assign({ resolveItems: defaultResolveItems }, (getNextOnDeployPaginationState
+                ? { getNextDiscoveryState: getNextOnDeployPaginationState }
+                : {})),
+        }
+        : {}));
+};
 const convertIntegration = (definition) => {
     var _a, _b, _c;
     // Generate a unique reference key that will be used to reference the
@@ -94,7 +145,11 @@ const convertConfigPages = (pages, userLevelConfigured) => {
         }) })));
 };
 exports.convertConfigPages = convertConfigPages;
-const codeNativeIntegrationYaml = ({ name, description, category, documentation, version, labels, endpointType, triggerPreprocessFlowConfig, flows, configPages, userLevelConfigPages, scopedConfigVars, instanceProfile, componentRegistry = {}, }, referenceKey, configVars, metadata) => {
+const codeNativeIntegrationYaml = ({ name, description, category, documentation, version, labels, endpointType, triggerPreprocessFlowConfig, flows: rawFlows, configPages, userLevelConfigPages, scopedConfigVars, instanceProfile, componentRegistry = {}, }, referenceKey, configVars, metadata) => {
+    // Expand any batched `trigger` (built with `batchFlowTrigger`) into the flat
+    // onTrigger/onDeployTrigger/triggerResolver/onDeployResolver shape the rest of this
+    // pipeline (convertFlow + the trigger reducer) already handles.
+    const flows = rawFlows.map((flow) => normalizeBatchedFlow(flow));
     // Find the preprocess flow config on the flow, if one exists.
     const preprocessFlows = flows.filter((flow) => flow.preprocessFlowConfig);
     // Do some validation of preprocess flow configs.
@@ -310,8 +365,11 @@ const convertFlowSchemas = (flowKey, schemas) => {
     }, {});
 };
 /** Converts a Flow into the structure necessary for YAML generation. */
-const convertFlow = (flow, componentRegistry, referenceKey) => {
+const convertFlow = (rawFlow, componentRegistry, referenceKey) => {
     var _a;
+    // Expand a batched `trigger` into the flat shape this function serializes. Idempotent: a flow
+    // that already lacks `trigger` (including one pre-normalized by `convertIntegration`) is returned as-is.
+    const flow = normalizeBatchedFlow(rawFlow);
     const result = Object.assign({}, flow);
     result.onTrigger = undefined;
     result.trigger = undefined;
@@ -319,6 +377,7 @@ const convertFlow = (flow, componentRegistry, referenceKey) => {
     result.onInstanceDelete = undefined;
     result.webhookLifecycleHandlers = undefined;
     result.onExecution = undefined;
+    result.onDeployTrigger = undefined;
     result.preprocessFlowConfig = undefined;
     result.errorConfig = undefined;
     result.testApiKeys = undefined;
@@ -412,6 +471,30 @@ const convertFlow = (flow, componentRegistry, referenceKey) => {
             }
             : {}));
     }
+    const triggerResolver = "triggerResolver" in flow ? flow.triggerResolver : undefined;
+    const onDeployResolver = "onDeployResolver" in flow ? flow.onDeployResolver : undefined;
+    const batchConfig = "batchConfig" in flow ? flow.batchConfig : undefined;
+    // Resolver behaviors (resolveItems/getNextDiscoveryState) are serialized onto the
+    // synthesized trigger below. On the flow wire we emit only `triggerResolver`, the single
+    // config the platform reads (`trigger_resolver_batch_size` / `trigger_resolver_enabled`)
+    // and shares between the normal and on-deploy fires. `batchConfig`/`onDeployResolver` are
+    // author-side only — clear them out of the `{ ...flow }` spread.
+    result.triggerResolver = undefined;
+    result.onDeployResolver = undefined;
+    result.batchConfig = undefined;
+    if (triggerResolver || onDeployResolver) {
+        if (!batchConfig) {
+            throw new Error(`${flow.name} defines a triggerResolver/onDeployResolver but no batchConfig. Add \`batchConfig: { batchSize }\` to the flow.`);
+        }
+        if (onDeployResolver &&
+            (!("onDeployTrigger" in flow) || typeof flow.onDeployTrigger !== "function")) {
+            throw new Error(`${flow.name} declares onDeployResolver without onDeployTrigger. Set onDeployTrigger to handle the initial-deploy fire that the resolver fans out.`);
+        }
+        // `enabled: true` is required: for a "valid"-support trigger (which CNI synthesized
+        // triggers are) the platform only batches when the flow's resolver is enabled.
+        const concurrentBatchLimit = (0, convertComponent_1.validateConcurrentBatchLimit)(flow.name, "batchConfig", batchConfig.concurrentBatchLimit);
+        result.triggerResolver = Object.assign({ batchSize: (0, convertComponent_1.validateBatchSize)(flow.name, "batchConfig", batchConfig.batchSize), enabled: true }, (concurrentBatchLimit !== undefined ? { concurrentBatchLimit } : {}));
+    }
     const actionStep = {
         action: {
             key: flowFunctionKey(flow.name, "onExecution"),
@@ -695,7 +778,11 @@ function generateTriggerPerformFn(params) {
         case "standard":
             return (0, perform_1.createCNIPerform)({ componentRegistry, onTrigger });
         case "component-ref":
-            return (0, perform_1.createCNIComponentRefPerform)({ componentRegistry, componentRef, onTrigger });
+            return (0, perform_1.createCNIComponentRefPerform)({
+                componentRegistry,
+                componentRef,
+                onTrigger,
+            });
         default:
             throw new Error(`Invalid trigger configuration detected: ${JSON.stringify(params, null, 2)}`);
     }
@@ -751,7 +838,9 @@ const convertOnExecution = (onExecution, componentRegistry) => (context, params)
 });
 /** Creates the structure necessary to import a Component as part of a
  *  Code Native integration. */
-const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [], componentRegistry = {}, }, referenceKey, configVars) => {
+const codeNativeIntegrationComponent = ({ name, iconPath, description, flows: rawFlows = [], componentRegistry = {}, }, referenceKey, configVars) => {
+    // Expand any batched `trigger` so the action/trigger reducers below see the flat shape.
+    const flows = rawFlows.map((flow) => normalizeBatchedFlow(flow));
     const convertedActions = flows.reduce((result, { name, onExecution }) => {
         const key = flowFunctionKey(name, "onExecution");
         return Object.assign(Object.assign({}, result), { [key]: {
@@ -764,7 +853,12 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
                 inputs: [],
             } });
     }, {});
-    const convertedTriggers = flows.reduce((result, { name, onTrigger, onInstanceDeploy, onInstanceDelete, webhookLifecycleHandlers, schedule, triggerType, }) => {
+    const convertedTriggers = flows.reduce((result, flow) => {
+        var _a;
+        const { name, onTrigger, onInstanceDeploy, onInstanceDelete, webhookLifecycleHandlers, schedule, triggerType, onDeployTrigger, } = flow;
+        // `batchConfig`/`triggerResolver`/`onDeployResolver` are wire-only fields synthesized by
+        // `normalizeBatchedFlow`; they aren't on the author-facing `Flow` type, so read via cast.
+        const { batchConfig, triggerResolver, onDeployResolver } = flow;
         if (!flowUsesWrapperTrigger({
             onTrigger,
             onInstanceDelete,
@@ -799,26 +893,45 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
         const deployFn = generateTriggerEventWrapperFn(ref, onTrigger, "onInstanceDeploy", componentRegistry, onInstanceDeploy);
         const webhookCreateFn = generateTriggerEventWrapperFn(ref, onTrigger, "webhookCreate", componentRegistry, webhookLifecycleHandlers === null || webhookLifecycleHandlers === void 0 ? void 0 : webhookLifecycleHandlers.create);
         const webhookDeleteFn = generateTriggerEventWrapperFn(ref, onTrigger, "webhookDelete", componentRegistry, webhookLifecycleHandlers === null || webhookLifecycleHandlers === void 0 ? void 0 : webhookLifecycleHandlers.delete);
-        return Object.assign(Object.assign({}, result), { [key]: {
-                key,
-                display: {
+        return Object.assign(Object.assign({}, result), { [key]: Object.assign(Object.assign(Object.assign(Object.assign({ key, display: {
                     label: `${name} - onTrigger`,
                     description: "The function that will be executed by the flow to return an HTTP response.",
-                },
-                perform: performFn,
-                onInstanceDeploy: deployFn,
-                hasOnInstanceDeploy: !!deployFn,
-                onInstanceDelete: deleteFn,
-                hasOnInstanceDelete: !!deleteFn,
-                webhookCreate: webhookCreateFn,
-                hasWebhookCreateFunction: !!webhookCreateFn,
-                webhookDelete: webhookDeleteFn,
-                hasWebhookDeleteFunction: !!webhookDeleteFn,
-                inputs: wrapperTriggerInputsFromReference(onTrigger, componentRegistry),
-                scheduleSupport: triggerType === "polling" ? "required" : "valid",
-                synchronousResponseSupport: "valid",
-                isPollingTrigger: triggerType === "polling",
-            } });
+                }, perform: performFn, onInstanceDeploy: deployFn, hasOnInstanceDeploy: !!deployFn, onInstanceDelete: deleteFn, hasOnInstanceDelete: !!deleteFn, webhookCreate: webhookCreateFn, hasWebhookCreateFunction: !!webhookCreateFn, webhookDelete: webhookDeleteFn, hasWebhookDeleteFunction: !!webhookDeleteFn, inputs: wrapperTriggerInputsFromReference(onTrigger, componentRegistry), scheduleSupport: triggerType === "polling" ? "required" : "valid", synchronousResponseSupport: "valid", isPollingTrigger: triggerType === "polling", triggerResolverSupport: triggerResolver ? "valid" : "invalid" }, (triggerResolver || onDeployResolver
+                ? Object.assign({ triggerResolverDefaultBatchSize: (_a = batchConfig === null || batchConfig === void 0 ? void 0 : batchConfig.batchSize) !== null && _a !== void 0 ? _a : 1 }, ((batchConfig === null || batchConfig === void 0 ? void 0 : batchConfig.concurrentBatchLimit) !== undefined
+                    ? {
+                        triggerResolverDefaultConcurrentBatchLimit: batchConfig.concurrentBatchLimit,
+                    }
+                    : {})) : {})), (triggerResolver
+                ? Object.assign(Object.assign({}, (triggerResolver.resolveItems
+                    ? {
+                        resolveTriggerItems: triggerResolver.resolveItems,
+                        hasResolveTriggerItems: true,
+                    }
+                    : {})), (triggerResolver.getNextDiscoveryState
+                    ? {
+                        getNextDiscoveryState: triggerResolver.getNextDiscoveryState,
+                        hasGetNextDiscoveryState: true,
+                    }
+                    : {})) : {})), (onDeployTrigger
+                ? {
+                    onDeployPerform: (0, perform_1.createCNIPerform)({
+                        componentRegistry,
+                        onTrigger: onDeployTrigger,
+                    }),
+                    hasOnDeployPerform: true,
+                }
+                : {})), (onDeployResolver
+                ? Object.assign(Object.assign({}, (onDeployResolver.resolveItems
+                    ? {
+                        resolveOnDeployItems: onDeployResolver.resolveItems,
+                        hasResolveOnDeployItems: true,
+                    }
+                    : {})), (onDeployResolver.getNextDiscoveryState
+                    ? {
+                        getOnDeployNextDiscoveryState: onDeployResolver.getNextDiscoveryState,
+                        hasGetOnDeployNextDiscoveryState: true,
+                    }
+                    : {})) : {})) });
     }, {});
     const convertedDataSources = Object.entries(configVars).reduce((result, [key, configVar]) => {
         if (!(0, types_1.isDataSourceDefinitionConfigVar)(configVar)) {

package/dist/serverTypes/index.d.ts

@@ -112,8 +112,8 @@ interface HttpResponse {
     headers?: Record<string, string>;
     body?: string;
 }
-interface TriggerBaseResult {
-    payload: TriggerPayload;
+interface TriggerBaseResult<TPayload extends TriggerPayload = TriggerPayload> {
+    payload: TPayload;
     response?: HttpResponse;
     instanceState?: Record<string, unknown>;
     crossFlowState?: Record<string, unknown>;
@@ -122,12 +122,23 @@ interface TriggerBaseResult {
     failed?: boolean;
     error?: Record<string, unknown>;
 }
-interface TriggerBranchingResult extends TriggerBaseResult {
+interface TriggerBranchingResult<TPayload extends TriggerPayload = TriggerPayload> extends TriggerBaseResult<TPayload> {
     branch: string;
 }
-export type TriggerResult = TriggerBranchingResult | TriggerBaseResult | undefined;
+export type TriggerResult<TPayload extends TriggerPayload = TriggerPayload> = TriggerBranchingResult<TPayload> | TriggerBaseResult<TPayload> | undefined;
 export type TriggerEventFunctionResult = TriggerEventFunctionReturn | void;
 export type TriggerEventFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
+/**
+ * Wire format the platform expects for a trigger. Note: function references
+ * (perform, resolveTriggerItems, getNextDiscoveryState, ...) don't survive JSON
+ * serialization, so each callback has a paired `hasXxx: boolean` flag the
+ * server reads to detect presence. Keep the flag and its callback in sync.
+ *
+ * The on-deploy fire is named asymmetrically by intent: CNI flow authors set
+ * `onDeployTrigger` (sibling to `onTrigger`), component-trigger authors set
+ * `onDeployPerform` (sibling to `perform`), and both flatten to
+ * `onDeployPerform` here on the wire.
+ */
 export interface Trigger<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerPerformResult<TAllowsBranching, TPayload> = TriggerPerformResult<TAllowsBranching, TPayload>> {
     key: string;
     display: DisplayDefinition & {
@@ -155,6 +166,23 @@ export interface Trigger<TInputs extends Inputs, TActionInputs extends Inputs, T
     hasWebhookDeleteFunction?: boolean;
     scheduleSupport: TriggerOptionChoice;
     synchronousResponseSupport: TriggerOptionChoice;
+    triggerResolverSupport?: TriggerOptionChoice;
+    /**
+     * The single default batch size shared by the trigger and on-deploy resolvers. The
+     * platform reads only this field for both paths; there is no separate on-deploy default.
+     */
+    triggerResolverDefaultBatchSize?: number;
+    triggerResolverDefaultConcurrentBatchLimit?: number;
+    resolveTriggerItems?: (context: ActionContext<TConfigVars>, result: TriggerBaseResult<TPayload>) => unknown[];
+    hasResolveTriggerItems?: boolean;
+    getNextDiscoveryState?: (context: ActionContext<TConfigVars>, result: TriggerBaseResult<TPayload>) => Record<string, unknown> | null;
+    hasGetNextDiscoveryState?: boolean;
+    onDeployPerform?: TriggerPerformFunction<TInputs, TConfigVars, TAllowsBranching, TResult> | PollingTriggerPerformFunction<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult> | CNIPollingPerformFunction<TInputs, TConfigVars, TPayload, TAllowsBranching> | ComponentRefTriggerPerformFunction<TInputs, TConfigVars>;
+    hasOnDeployPerform?: boolean;
+    resolveOnDeployItems?: (context: ActionContext<TConfigVars>, result: TriggerBaseResult<TPayload>) => unknown[];
+    hasResolveOnDeployItems?: boolean;
+    getOnDeployNextDiscoveryState?: (context: ActionContext<TConfigVars>, result: TriggerBaseResult<TPayload>) => Record<string, unknown> | null;
+    hasGetOnDeployNextDiscoveryState?: boolean;
     examplePayload?: unknown;
     isCommonTrigger?: boolean;
     isPollingTrigger?: boolean;
@@ -262,5 +290,8 @@ export interface Input {
     onPremiseControlled?: boolean;
     dataSource?: string;
     shown?: boolean;
+    /** Nested children. For `structuredObject`, the declared inputs; for
+     * `dynamicObject`, one `structuredObject` per configuration. */
+    inputs?: Input[];
 }
 export * from "./asyncContext";

package/dist/testing.d.ts

@@ -217,7 +217,7 @@ type ToTestValues<TConfigVars extends ConfigVarResultCollection> = {
  *   expect(result.data).toBeDefined();
  * });
  */
-export declare const invokeFlow: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TConfigVarValues extends TestConfigVarValues = ToTestValues<TConfigVars>, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends InvokeTriggerResult<TAllowsBranching, TPayload> = InvokeTriggerResult<TAllowsBranching, TPayload>>(flow: Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>, { configVars, context, payload, }?: {
+export declare const invokeFlow: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TConfigVarValues extends TestConfigVarValues = ToTestValues<TConfigVars>, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends InvokeTriggerResult<TAllowsBranching, TPayload> = InvokeTriggerResult<TAllowsBranching, TPayload>>(flow: Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, any, any, any>, { configVars, context, payload, }?: {
     configVars?: TConfigVarValues;
     context?: Partial<ActionContext<TConfigVars>>;
     payload?: Partial<TriggerPayload>;

package/dist/testing.js

@@ -408,7 +408,11 @@ const createConfigVars = (values) => {
  *   expect(result.data).toBeDefined();
  * });
  */
-const invokeFlow = (flow_1, ...args_1) => __awaiter(void 0, [flow_1, ...args_1], void 0, function* (flow, { configVars, context, payload, } = {}) {
+const invokeFlow = (flow_1, ...args_1) => __awaiter(void 0, [flow_1, ...args_1], void 0, function* (
+// `any` for TItem/TDiscoveryState/TTriggerPayload: the tester accepts a flow with any
+// resolver item and cursor typing; it drives the flow dynamically and does not rely on
+// the precise `onExecution` param type.
+flow, { configVars, context, payload, } = {}) {
     const realizedConfigVars = createConfigVars(configVars);
     const realizedContext = createActionContext(Object.assign(Object.assign({}, context), { configVars: realizedConfigVars }));
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);

package/dist/types/ActionInputParameters.d.ts

@@ -1,11 +1,40 @@
 import type { ConditionalExpression } from "./conditional-logic";
-import type { Connection, InputCleanFunction, InputFieldCollection, Inputs, KeyValuePair } from "./Inputs";
+import type { Connection, DynamicObjectInputField, InputCleanFunction, InputFieldCollection, Inputs, KeyValuePair, StructuredObjectInputField } from "./Inputs";
+/** Resolves a single InputFieldDefinition's runtime value type.
+ * - structuredObject: record of declared children's resolved value types.
+ * - dynamicObject: discriminated union keyed by the selected configuration,
+ *   with the configuration's resolved inputs nested under `values` to avoid
+ *   collisions with the `configuration` discriminant key.
+ * The depth caps (`LeafInputFieldDefinition`, `StructuredOrLeafInputFieldDefinition`)
+ * prevent unbounded recursion. */
+type InputValue<T> = T extends StructuredObjectInputField ? {
+    [K in keyof T["inputs"]]: InputValue<T["inputs"][K]>;
+} : T extends DynamicObjectInputField ? {
+    [C in keyof T["configurations"]]: {
+        configuration: C;
+        values: {
+            [K in keyof T["configurations"][C]["inputs"]]: InputValue<T["configurations"][C]["inputs"][K]>;
+        };
+    };
+}[keyof T["configurations"]] : T extends {
+    clean: InputCleanFunction<any>;
+} ? ReturnType<T["clean"]> : T extends {
+    type: "connection";
+    collection?: InputFieldCollection;
+} ? ExtractValue<Connection, T["collection"]> : T extends {
+    type: "conditional";
+    collection?: InputFieldCollection;
+} ? ExtractValue<ConditionalExpression, T["collection"]> : T extends {
+    default?: unknown;
+    collection?: InputFieldCollection;
+} ? ExtractValue<T["default"], T["collection"]> : unknown;
 /**
  * Collection of input parameters.
  * Inputs can be static values, references to config variables, or
  * references to previous steps' outputs.
  */
 export type ActionInputParameters<TInputs extends Inputs> = {
-    [Property in keyof TInputs]: TInputs[Property]["clean"] extends InputCleanFunction<any> ? ReturnType<TInputs[Property]["clean"]> : TInputs[Property]["type"] extends "connection" ? ExtractValue<Connection, TInputs[Property]["collection"]> : TInputs[Property]["type"] extends "conditional" ? ExtractValue<ConditionalExpression, TInputs[Property]["collection"]> : ExtractValue<TInputs[Property]["default"], TInputs[Property]["collection"]>;
+    [Property in keyof TInputs]: InputValue<TInputs[Property]>;
 };
 export type ExtractValue<TType, TCollection extends InputFieldCollection | undefined> = TCollection extends "keyvaluelist" ? KeyValuePair<TType>[] : TCollection extends "valuelist" ? TType[] : TType;
+export {};

package/dist/types/Inputs.d.ts

@@ -63,6 +63,8 @@ export type JSONForm = {
 };
 export type DynamicObjectSelection = string;
 export type DynamicFieldSelection = string;
+export type StructuredObject = Record<string, unknown>;
+export type DynamicObject = Record<string, unknown>;
 /** InputField type enumeration. */
 export type InputFieldType = InputFieldDefinition["type"];
 export declare const InputFieldDefaultMap: Record<InputFieldType, string | undefined>;
@@ -83,7 +85,7 @@ export type OnPremConnectionInput = {
      */
     onPremControlled: true;
 } & ConnectionInput;
-export type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField | ConnectionTemplateInputField | ObjectSelectionInputField | ObjectFieldMapInputField | JSONFormInputField | DynamicObjectSelectionInputField | DynamicFieldSelectionInputField | DateInputField | DateTimeInputField | FlowInputField;
+export type InputFieldDefinition = StringInputField | DataInputField | TextInputField | PasswordInputField | BooleanInputField | CodeInputField | ConditionalInputField | ConnectionInputField | ConnectionTemplateInputField | ObjectSelectionInputField | ObjectFieldMapInputField | JSONFormInputField | DynamicObjectSelectionInputField | DynamicFieldSelectionInputField | DateInputField | DateTimeInputField | FlowInputField | StructuredObjectInputField | DynamicObjectInputField;
 export type InputCleanFunction<TValue, TResult = TValue> = (value: TValue) => TResult;
 interface BaseInputField {
     /** Name of this field to present in the UI. */
@@ -289,6 +291,50 @@ export type DateTimeInputField = BaseInputField & {
     /** Clean function. */
     clean?: InputCleanFunction<unknown>;
 } & CollectionOptions<string>;
+/** `InputFieldDefinition` minus container input types and connection
+ * pickers. Connections resolve to config-var references outside the
+ * parent's value tree, so they're only valid at the top level — never as
+ * a child of a structuredObject or a dynamicObject configuration. */
+export type LeafInputFieldDefinition = Exclude<InputFieldDefinition, StructuredObjectInputField | DynamicObjectInputField | ConnectionInputField | ConnectionTemplateInputField>;
+/** `LeafInputFieldDefinition` plus `StructuredObjectInputField`; used
+ * inside a dynamicObject's `configurations.<key>.inputs` to allow leaves
+ * and structuredObject children while still rejecting nested
+ * dynamicObjects and connection pickers. */
+export type StructuredOrLeafInputFieldDefinition = LeafInputFieldDefinition | StructuredObjectInputField;
+/** Groups related primitive inputs under a single named container.
+ * Nesting is capped at one level. Connection pickers are rejected as
+ * children — they may only appear at the top level. */
+export type StructuredObjectInputField = Omit<BaseInputField, "dataSource" | "example" | "placeholder" | "required"> & {
+    /** Data type the input will collect. */
+    type: "structuredObject";
+    /** Nested input fields keyed by their local key. */
+    inputs: Record<string, LeafInputFieldDefinition>;
+};
+/** A single configuration within a dynamicObject. Each configuration declares
+ * a labeled set of inputs that become available when this configuration is
+ * selected at runtime. */
+export interface DynamicObjectConfiguration {
+    /** Name of this configuration to present in the UI. */
+    label: {
+        key: string;
+        value: string;
+    } | string;
+    /** Additional text to give guidance to the user when this configuration is selected. */
+    comments?: string;
+    /** Inputs that become available when this configuration is selected. */
+    inputs: Record<string, StructuredOrLeafInputFieldDefinition>;
+}
+/** Presents a discriminated set of input groups; the user picks a configuration
+ * at integration-build time and that configuration's inputs become available.
+ * Nesting is capped: configurations may contain structuredObject children
+ * (depth-1) but never another dynamicObject. */
+export type DynamicObjectInputField = Omit<BaseInputField, "dataSource" | "example" | "placeholder"> & {
+    /** Data type the input will collect. */
+    type: "dynamicObject";
+    /** Available configurations keyed by their local key (used as the
+     * runtime discriminant). */
+    configurations: Record<string, DynamicObjectConfiguration>;
+};
 /** Defines a single Choice option for a InputField. */
 export interface InputFieldChoice {
     /** Label to display for this Choice. */

package/dist/types/Inputs.js

@@ -19,4 +19,6 @@ exports.InputFieldDefaultMap = {
     timestamp: "",
     flow: "",
     template: "",
+    structuredObject: undefined,
+    dynamicObject: undefined,
 };