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

package/dist/generators/componentManifest/getInputs.js

@@ -3,13 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.INPUT_TYPE_MAP = exports.getInputs = void 0;
 const escapeSpecialCharacters_1 = require("../utils/escapeSpecialCharacters");
 const docBlock_1 = require("./docBlock");
-const getDefaultValue = (value, isCollection) => {
-    if (value === undefined || value === "") {
-        return isCollection ? [] : value;
-    }
-    const stringValue = typeof value === "string" ? value : JSON.stringify(value);
-    return (0, escapeSpecialCharacters_1.escapeSpecialCharacters)(stringValue);
-};
 const getInputs = ({ inputs, docBlock = docBlock_1.DOC_BLOCK_DEFAULT }) => {
     return inputs.reduce((acc, input) => {
         if ((typeof input.shown === "boolean" && input.shown === false) ||
@@ -68,8 +61,23 @@ exports.INPUT_TYPE_MAP = {
     timestamp: "string",
     flow: "string",
     template: "string",
+    structuredObject: {
+        module: "@prismatic-io/spectral/dist/types",
+        type: "StructuredObject",
+    },
+    dynamicObject: {
+        module: "@prismatic-io/spectral/dist/types",
+        type: "DynamicObject",
+    },
 };
 const getInputValueType = (input) => {
+    var _a, _b;
+    if (input.type === "structuredObject") {
+        return structuredObjectTypeString((_a = input.inputs) !== null && _a !== void 0 ? _a : []);
+    }
+    if (input.type === "dynamicObject") {
+        return dynamicObjectTypeString((_b = input.inputs) !== null && _b !== void 0 ? _b : []);
+    }
     const inputType = exports.INPUT_TYPE_MAP[input.type];
     const valueType = input.model
         ? input.model
@@ -94,3 +102,70 @@ const getInputValueType = (input) => {
     }
     return valueType;
 };
+const getDefaultValue = (value, isCollection) => {
+    if (value === undefined || value === "") {
+        return isCollection ? [] : value;
+    }
+    const stringValue = typeof value === "string" ? value : JSON.stringify(value);
+    return (0, escapeSpecialCharacters_1.escapeSpecialCharacters)(stringValue);
+};
+const isValidIdentifier = (key) => /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+const wrapCollection = (valueType, collection) => {
+    if (collection === "valuelist") {
+        return `Array<${valueType}>`;
+    }
+    if (collection === "keyvaluelist") {
+        return `Record<string, ${valueType}> | Array<{key: string, value: ${valueType}}>`;
+    }
+    return valueType;
+};
+const getLeafBaseType = (child) => {
+    var _a;
+    if ((_a = child.model) === null || _a === void 0 ? void 0 : _a.length) {
+        return child.model
+            .map(({ value }) => `\`${value.replaceAll("\r", "\\r").replaceAll("\n", "\\n")}\``)
+            .join(" | ");
+    }
+    const mapped = exports.INPUT_TYPE_MAP[child.type];
+    if (!mapped) {
+        return "unknown";
+    }
+    if (typeof mapped === "string") {
+        return mapped;
+    }
+    return `import("${mapped.module}").${mapped.type}`;
+};
+const getLeafTypeString = (child) => {
+    var _a;
+    if (child.type === "structuredObject") {
+        return structuredObjectTypeString((_a = child.inputs) !== null && _a !== void 0 ? _a : []);
+    }
+    return wrapCollection(getLeafBaseType(child), child.collection);
+};
+const SPECTRAL_TYPES_MODULE = "@prismatic-io/spectral/dist/types";
+const structuredObjectTypeString = (inputs) => {
+    if (!inputs.length) {
+        return `import("${SPECTRAL_TYPES_MODULE}").StructuredObject`;
+    }
+    const fields = inputs
+        .map((child) => {
+        const key = isValidIdentifier(child.key) ? child.key : JSON.stringify(child.key);
+        return `${key}: ${getLeafTypeString(child)}`;
+    })
+        .join("; ");
+    return `{ ${fields} }`;
+};
+const dynamicObjectTypeString = (configurations) => {
+    if (!configurations.length) {
+        return `import("${SPECTRAL_TYPES_MODULE}").DynamicObject`;
+    }
+    return configurations
+        .map((config) => {
+        var _a;
+        const valuesType = ((_a = config.inputs) === null || _a === void 0 ? void 0 : _a.length)
+            ? structuredObjectTypeString(config.inputs)
+            : `import("${SPECTRAL_TYPES_MODULE}").StructuredObject`;
+        return `{ configuration: ${JSON.stringify(config.key)}; values: ${valuesType} }`;
+    })
+        .join(" | ");
+};

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  */
 import { convertComponent } from "./serverTypes/convertComponent";
 import { convertIntegration } from "./serverTypes/convertIntegration";
-import type { ActionDefinition, ActionPerformReturn, ComponentDefinition, ComponentManifest, ConfigPage, ConfigVarResultCollection, ConnectionConfigVar, CustomerActivatedConnectionConfigVar, DataSourceConfigVar, DataSourceDefinition, DataSourceType, DefaultConnectionDefinition, Flow, InputFieldDefinition, Inputs, IntegrationDefinition, OAuth2ConnectionDefinition, OnPremConnectionDefinition, OrganizationActivatedConnectionConfigVar, StandardConfigVar, TriggerDefinition, TriggerPayload, TriggerResult } from "./types";
+import type { ActionDefinition, ActionPerformReturn, BatchTrigger, ComponentDefinition, ComponentManifest, ConfigPage, ConfigVarResultCollection, ConnectionConfigVar, CustomerActivatedConnectionConfigVar, DataSourceConfigVar, DataSourceDefinition, DataSourceType, DefaultConnectionDefinition, DynamicObjectInputField, Flow, InputFieldDefinition, Inputs, IntegrationDefinition, OAuth2ConnectionDefinition, OnPremConnectionDefinition, OrganizationActivatedConnectionConfigVar, StandardConfigVar, StructuredObjectInputField, TriggerDefinition, TriggerPayload, TriggerResult } from "./types";
 import type { PollingTriggerDefinition } from "./types/PollingTriggerDefinition";
 /**
  * This function creates a code-native integration object that can be
@@ -73,7 +73,48 @@ export declare const integration: <TInputs extends Inputs, TActionInputs extends
  *   },
  * });
  */
-export declare const flow: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, TTriggerPayload extends TriggerPayload = TriggerPayload, T extends Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload> = Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload>>(definition: T) => T;
+export declare const flow: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, TTriggerPayload extends TriggerPayload = TriggerPayload, TItem = unknown, TDiscoveryState extends Record<string, unknown> = Record<string, unknown>, T extends Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload, TItem, TDiscoveryState> = Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload, TItem, TDiscoveryState>>(definition: T & {
+    trigger?: BatchTrigger<TItem, TDiscoveryState>;
+}) => T;
+/**
+ * Builds a flow's batched `trigger` — the ergonomic way to define a batching flow. Instead of
+ * writing `onTrigger`/`onDeployTrigger` (returning a full payload) plus `triggerResolver`/
+ * `onDeployResolver` (to extract and paginate), the trigger fires return just their `items` and
+ * the pagination callbacks live alongside them. spectral wraps the items into the wire payload
+ * and synthesizes the `resolveItems` that reads them back.
+ *
+ * Supply the item and pagination-state types explicitly —
+ * `batchFlowTrigger<Order, { cursor: number }>({ ... })`. They flow through the whole flow:
+ * the trigger fires return `Order[]`, `payload.discoveryState` reads back as `{ cursor: number }`,
+ * and the flow's `onExecution` sees `params.onTrigger.results.body.data` typed as `Order | Order[]`.
+ *
+ * @typeParam TItem - the item type each batched execution receives.
+ * @typeParam TPaginationState - the pagination state round-tripped via `payload.discoveryState`.
+ * @see {@link https://prismatic.io/docs/integrations/code-native/flows/ | Code-Native Flows}
+ * @example
+ * import { flow, batchFlowTrigger } from "@prismatic-io/spectral";
+ *
+ * flow({
+ *   name: "Sync Orders",
+ *   stableKey: "sync-orders",
+ *   batchConfig: { batchSize: 50 },
+ *   trigger: batchFlowTrigger<Order, { cursor: number }>({
+ *     onTrigger: async (context, payload) => {
+ *       const page = await fetchOrders(payload.discoveryState?.cursor);
+ *       return { items: page.orders };
+ *     },
+ *     getNextOnTriggerPaginationState: (context, result) => {
+ *       const next = result.payload.discoveryState?.cursor;
+ *       return next === undefined ? null : { cursor: next };
+ *     },
+ *   }),
+ *   onExecution: async (context, params) => {
+ *     const orders = params.onTrigger.results.body.data; // Order | Order[]
+ *     return { data: orders };
+ *   },
+ * });
+ */
+export declare const batchFlowTrigger: <TItem, TPaginationState extends Record<string, unknown> = Record<string, unknown>>(trigger: BatchTrigger<TItem, TPaginationState>) => BatchTrigger<TItem, TPaginationState>;
 /**
  * This function creates a config wizard page object for use in code-native
  * integrations.
@@ -512,6 +553,69 @@ export declare const dataSource: <TInputs extends Inputs, TConfigVars extends Co
  * });
  */
 export declare const input: <T extends InputFieldDefinition>(definition: T) => T;
+/**
+ * Groups related primitive inputs under a single named container. Children
+ * may not themselves be structuredObject inputs (the type signature enforces
+ * this at compile time).
+ *
+ * @example
+ * import { input, structuredObjectInput } from "@prismatic-io/spectral";
+ *
+ * const name = structuredObjectInput({
+ *   label: "Name",
+ *   inputs: {
+ *     first: input({ type: "string", label: "First Name", required: true }),
+ *     last: input({ type: "string", label: "Last Name", required: true }),
+ *   },
+ * });
+ */
+export declare const structuredObjectInput: <T extends Omit<StructuredObjectInputField, "type"> & {
+    type?: never;
+}>(definition: T) => T & {
+    type: "structuredObject";
+};
+/**
+ * Presents a discriminated set of input configurations; the integration builder
+ * picks a configuration and its inputs become available. Configurations may
+ * contain leaf inputs and structuredObject inputs but not nested dynamicObjects
+ * (the type signature enforces this at compile time).
+ *
+ * @example
+ * import { input, structuredObjectInput, dynamicObjectInput } from "@prismatic-io/spectral";
+ *
+ * const recordData = dynamicObjectInput({
+ *   label: "Record Data",
+ *   required: true,
+ *   configurations: {
+ *     contact: {
+ *       label: "Contact",
+ *       comments: "Create a new contact",
+ *       inputs: {
+ *         name: structuredObjectInput({
+ *           label: "Name",
+ *           inputs: {
+ *             first: input({ type: "string", label: "First Name", required: true }),
+ *             last: input({ type: "string", label: "Last Name", required: true }),
+ *           },
+ *         }),
+ *         email: input({ type: "string", label: "Email", required: true }),
+ *       },
+ *     },
+ *     account: {
+ *       label: "Account",
+ *       comments: "Create a new account",
+ *       inputs: {
+ *         companyName: input({ type: "string", label: "Company Name", required: true }),
+ *       },
+ *     },
+ *   },
+ * });
+ */
+export declare const dynamicObjectInput: <T extends Omit<DynamicObjectInputField, "type"> & {
+    type?: never;
+}>(definition: T) => T & {
+    type: "dynamicObject";
+};
 /**
  * This function creates a connection that can be used by a code-native integration
  * or custom component. Connections define the fields (API keys, tokens, etc.) needed

package/dist/index.js

@@ -22,7 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.util = exports.testing = exports.componentManifests = exports.oauth2Connection = exports.onPremConnection = exports.connection = exports.input = exports.dataSource = exports.pollingTrigger = exports.trigger = exports.action = exports.component = exports.componentManifest = exports.organizationActivatedConnection = exports.customerActivatedConnection = exports.connectionConfigVar = exports.dataSourceConfigVar = exports.configVar = exports.configPage = exports.flow = exports.integration = void 0;
+exports.util = exports.testing = exports.componentManifests = exports.oauth2Connection = exports.onPremConnection = exports.connection = exports.dynamicObjectInput = exports.structuredObjectInput = exports.input = exports.dataSource = exports.pollingTrigger = exports.trigger = exports.action = exports.component = exports.componentManifest = exports.organizationActivatedConnection = exports.customerActivatedConnection = exports.connectionConfigVar = exports.dataSourceConfigVar = exports.configVar = exports.configPage = exports.batchFlowTrigger = exports.flow = exports.integration = void 0;
 const serverTypes_1 = require("./serverTypes");
 const convertComponent_1 = require("./serverTypes/convertComponent");
 const convertIntegration_1 = require("./serverTypes/convertIntegration");
@@ -102,8 +102,53 @@ exports.integration = integration;
  *   },
  * });
  */
-const flow = (definition) => definition;
+const flow = (
+// The intersection adds an explicit inference site for `TItem`/`TDiscoveryState` that the
+// `T extends Flow<...>` capture alone does not provide, while `T` still preserves the precise
+// literal type for the return value. They are inferred from a batched `trigger`'s
+// `items`/pagination-state types (see `batchFlowTrigger`).
+definition) => definition;
 exports.flow = flow;
+/**
+ * Builds a flow's batched `trigger` — the ergonomic way to define a batching flow. Instead of
+ * writing `onTrigger`/`onDeployTrigger` (returning a full payload) plus `triggerResolver`/
+ * `onDeployResolver` (to extract and paginate), the trigger fires return just their `items` and
+ * the pagination callbacks live alongside them. spectral wraps the items into the wire payload
+ * and synthesizes the `resolveItems` that reads them back.
+ *
+ * Supply the item and pagination-state types explicitly —
+ * `batchFlowTrigger<Order, { cursor: number }>({ ... })`. They flow through the whole flow:
+ * the trigger fires return `Order[]`, `payload.discoveryState` reads back as `{ cursor: number }`,
+ * and the flow's `onExecution` sees `params.onTrigger.results.body.data` typed as `Order | Order[]`.
+ *
+ * @typeParam TItem - the item type each batched execution receives.
+ * @typeParam TPaginationState - the pagination state round-tripped via `payload.discoveryState`.
+ * @see {@link https://prismatic.io/docs/integrations/code-native/flows/ | Code-Native Flows}
+ * @example
+ * import { flow, batchFlowTrigger } from "@prismatic-io/spectral";
+ *
+ * flow({
+ *   name: "Sync Orders",
+ *   stableKey: "sync-orders",
+ *   batchConfig: { batchSize: 50 },
+ *   trigger: batchFlowTrigger<Order, { cursor: number }>({
+ *     onTrigger: async (context, payload) => {
+ *       const page = await fetchOrders(payload.discoveryState?.cursor);
+ *       return { items: page.orders };
+ *     },
+ *     getNextOnTriggerPaginationState: (context, result) => {
+ *       const next = result.payload.discoveryState?.cursor;
+ *       return next === undefined ? null : { cursor: next };
+ *     },
+ *   }),
+ *   onExecution: async (context, params) => {
+ *     const orders = params.onTrigger.results.body.data; // Order | Order[]
+ *     return { data: orders };
+ *   },
+ * });
+ */
+const batchFlowTrigger = (trigger) => trigger;
+exports.batchFlowTrigger = batchFlowTrigger;
 /**
  * This function creates a config wizard page object for use in code-native
  * integrations.
@@ -557,6 +602,63 @@ exports.dataSource = dataSource;
  */
 const input = (definition) => definition;
 exports.input = input;
+/**
+ * Groups related primitive inputs under a single named container. Children
+ * may not themselves be structuredObject inputs (the type signature enforces
+ * this at compile time).
+ *
+ * @example
+ * import { input, structuredObjectInput } from "@prismatic-io/spectral";
+ *
+ * const name = structuredObjectInput({
+ *   label: "Name",
+ *   inputs: {
+ *     first: input({ type: "string", label: "First Name", required: true }),
+ *     last: input({ type: "string", label: "Last Name", required: true }),
+ *   },
+ * });
+ */
+const structuredObjectInput = (definition) => (Object.assign(Object.assign({}, definition), { type: "structuredObject" }));
+exports.structuredObjectInput = structuredObjectInput;
+/**
+ * Presents a discriminated set of input configurations; the integration builder
+ * picks a configuration and its inputs become available. Configurations may
+ * contain leaf inputs and structuredObject inputs but not nested dynamicObjects
+ * (the type signature enforces this at compile time).
+ *
+ * @example
+ * import { input, structuredObjectInput, dynamicObjectInput } from "@prismatic-io/spectral";
+ *
+ * const recordData = dynamicObjectInput({
+ *   label: "Record Data",
+ *   required: true,
+ *   configurations: {
+ *     contact: {
+ *       label: "Contact",
+ *       comments: "Create a new contact",
+ *       inputs: {
+ *         name: structuredObjectInput({
+ *           label: "Name",
+ *           inputs: {
+ *             first: input({ type: "string", label: "First Name", required: true }),
+ *             last: input({ type: "string", label: "Last Name", required: true }),
+ *           },
+ *         }),
+ *         email: input({ type: "string", label: "Email", required: true }),
+ *       },
+ *     },
+ *     account: {
+ *       label: "Account",
+ *       comments: "Create a new account",
+ *       inputs: {
+ *         companyName: input({ type: "string", label: "Company Name", required: true }),
+ *       },
+ *     },
+ *   },
+ * });
+ */
+const dynamicObjectInput = (definition) => (Object.assign(Object.assign({}, definition), { type: "dynamicObject" }));
+exports.dynamicObjectInput = dynamicObjectInput;
 /**
  * This function creates a connection that can be used by a code-native integration
  * or custom component. Connections define the fields (API keys, tokens, etc.) needed

package/dist/serverTypes/convertComponent.d.ts

@@ -1,7 +1,25 @@
 import { type ComponentDefinition, type ComponentHooks, type ConfigVarResultCollection, type ConnectionDefinition, type ConnectionInput, type ConnectionTemplateInputField, type InputFieldDefinition, type Inputs, type OnPremConnectionInput, type TriggerDefinition, type TriggerPayload, type TriggerResult } from "../types";
 import { type PollingTriggerDefinition } from "../types/PollingTriggerDefinition";
 import type { Component as ServerComponent, Connection as ServerConnection, Input as ServerInput, Trigger as ServerTrigger } from ".";
-export declare const convertInput: (key: string, { default: defaultValue, type, label, collection, ...rest }: InputFieldDefinition | OnPremConnectionInput | ConnectionInput) => ServerInput;
+import { type CleanFn } from "./perform";
+/** Auto-generated cleaner for structuredObject/dynamicObject containers.
+ * Recursively delegates to each child's clean function. Developers do not
+ * declare a top-level clean on these containers — the conversion always
+ * supplies one so nested clean functions are applied at runtime. */
+export declare const cleanerFor: (input: InputFieldDefinition) => CleanFn | undefined;
+/**
+ * Throws if `batchSize` isn't a positive integer; otherwise returns it. Shared by the
+ * component-trigger (`TriggerDefinition.batch.batchSize`) and CNI flow (`flow.batch.batchSize`)
+ * validation paths.
+ */
+export declare const validateBatchSize: (ownerLabel: string, fieldName: string, batchSize: unknown) => number;
+/**
+ * Throws if `concurrentBatchLimit` is set but isn't a positive integer; returns it
+ * unchanged (including `undefined`, which the platform treats as unlimited). Shared by the
+ * component-trigger and CNI flow paths, both sourcing it from the single `batchConfig`.
+ */
+export declare const validateConcurrentBatchLimit: (ownerLabel: string, fieldName: string, concurrentBatchLimit: unknown) => number | undefined;
+export declare const convertInput: (key: string, definition: InputFieldDefinition | OnPremConnectionInput | ConnectionInput) => ServerInput;
 export declare const _isValidTemplateValue: (template: string, inputs: {
     [key: string]: ConnectionInput | ConnectionTemplateInputField;
 }) => {

package/dist/serverTypes/convertComponent.js

@@ -14,21 +14,155 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertComponent = exports.convertConnection = exports.convertTrigger = exports.convertTemplateInput = exports._isValidTemplateValue = exports.convertInput = void 0;
+exports.convertComponent = exports.convertConnection = exports.convertTrigger = exports.convertTemplateInput = exports._isValidTemplateValue = exports.convertInput = exports.validateConcurrentBatchLimit = exports.validateBatchSize = exports.cleanerFor = void 0;
 const omit_1 = __importDefault(require("lodash/omit"));
 const types_1 = require("../types");
 const PollingTriggerDefinition_1 = require("../types/PollingTriggerDefinition");
 const perform_1 = require("./perform");
-const convertInput = (key, _a) => {
-    var { default: defaultValue, type, label, collection } = _a, rest = __rest(_a, ["default", "type", "label", "collection"]);
+const isPlainObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+/** Auto-generated cleaner for structuredObject/dynamicObject containers.
+ * Recursively delegates to each child's clean function. Developers do not
+ * declare a top-level clean on these containers — the conversion always
+ * supplies one so nested clean functions are applied at runtime. */
+const cleanerFor = (input) => {
+    if (input.type === "structuredObject") {
+        const childCleaners = Object.entries(input.inputs).reduce((acc, [childKey, childDef]) => (Object.assign(Object.assign({}, acc), { [childKey]: (0, exports.cleanerFor)(childDef) })), {});
+        return (value) => {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            return (0, perform_1.cleanParams)(value, childCleaners);
+        };
+    }
+    if (input.type === "dynamicObject") {
+        const configCleaners = {};
+        for (const [configKey, configDef] of Object.entries(input.configurations)) {
+            configCleaners[configKey] = Object.entries(configDef.inputs).reduce((acc, [childKey, childDef]) => (Object.assign(Object.assign({}, acc), { [childKey]: (0, exports.cleanerFor)(childDef) })), {});
+        }
+        return (value) => {
+            if (!isPlainObject(value)) {
+                return value;
+            }
+            const { configuration, values } = value;
+            if (typeof configuration !== "string") {
+                return value;
+            }
+            const cleaners = configCleaners[configuration];
+            if (!cleaners) {
+                return { configuration, values };
+            }
+            return {
+                configuration,
+                values: isPlainObject(values) ? (0, perform_1.cleanParams)(values, cleaners) : values,
+            };
+        };
+    }
+    return "clean" in input ? input.clean : undefined;
+};
+exports.cleanerFor = cleanerFor;
+/**
+ * Throws if `batchSize` isn't a positive integer; otherwise returns it. Shared by the
+ * component-trigger (`TriggerDefinition.batch.batchSize`) and CNI flow (`flow.batch.batchSize`)
+ * validation paths.
+ */
+const validateBatchSize = (ownerLabel, fieldName, batchSize) => {
+    if (typeof batchSize !== "number" || !Number.isInteger(batchSize) || batchSize < 1) {
+        throw new Error(`${ownerLabel} has an invalid ${fieldName} batchSize of ${String(batchSize)}. batchSize must be an integer >= 1.`);
+    }
+    return batchSize;
+};
+exports.validateBatchSize = validateBatchSize;
+/**
+ * Throws if `concurrentBatchLimit` is set but isn't a positive integer; returns it
+ * unchanged (including `undefined`, which the platform treats as unlimited). Shared by the
+ * component-trigger and CNI flow paths, both sourcing it from the single `batchConfig`.
+ */
+const validateConcurrentBatchLimit = (ownerLabel, fieldName, concurrentBatchLimit) => {
+    if (concurrentBatchLimit === undefined) {
+        return undefined;
+    }
+    if (typeof concurrentBatchLimit !== "number" ||
+        !Number.isInteger(concurrentBatchLimit) ||
+        concurrentBatchLimit < 1) {
+        throw new Error(`${ownerLabel} has an invalid ${fieldName} concurrentBatchLimit of ${String(concurrentBatchLimit)}. concurrentBatchLimit must be an integer >= 1.`);
+    }
+    return concurrentBatchLimit;
+};
+exports.validateConcurrentBatchLimit = validateConcurrentBatchLimit;
+/**
+ * Emits the trigger's single default batch size to the one wire field the platform reads
+ * (`triggerResolverDefaultBatchSize`), shared by both the trigger and on-deploy resolution.
+ * Emitted when the trigger declares a resolver — `triggerResolverSupport` `"valid"`/`"required"`
+ * for the normal path, or an `onDeployResolver` for the on-deploy path. Defaults to 1 when no
+ * `batchConfig` was declared.
+ */
+const buildBatchDefaultField = (triggerLabel, triggerResolverSupport, hasOnDeployResolver, batchConfig) => {
+    if (triggerResolverSupport === "invalid" && !hasOnDeployResolver) {
+        return {};
+    }
+    const concurrentBatchLimit = batchConfig
+        ? (0, exports.validateConcurrentBatchLimit)(`Trigger "${triggerLabel}"`, "batchConfig", batchConfig.concurrentBatchLimit)
+        : undefined;
+    return Object.assign({ triggerResolverDefaultBatchSize: batchConfig
+            ? (0, exports.validateBatchSize)(`Trigger "${triggerLabel}"`, "batchConfig", batchConfig.batchSize)
+            : 1 }, (concurrentBatchLimit !== undefined
+        ? { triggerResolverDefaultConcurrentBatchLimit: concurrentBatchLimit }
+        : {}));
+};
+const buildTriggerResolverFields = (resolver) => {
+    if (!resolver) {
+        return {};
+    }
+    return Object.assign(Object.assign({}, (resolver.resolveItems
+        ? {
+            resolveTriggerItems: resolver.resolveItems,
+            hasResolveTriggerItems: true,
+        }
+        : {})), (resolver.getNextDiscoveryState
+        ? {
+            getNextDiscoveryState: resolver.getNextDiscoveryState,
+            hasGetNextDiscoveryState: true,
+        }
+        : {}));
+};
+const buildOnDeployResolverFields = (resolver) => {
+    if (!resolver) {
+        return {};
+    }
+    return Object.assign(Object.assign({}, (resolver.resolveItems
+        ? {
+            resolveOnDeployItems: resolver.resolveItems,
+            hasResolveOnDeployItems: true,
+        }
+        : {})), (resolver.getNextDiscoveryState
+        ? {
+            getOnDeployNextDiscoveryState: resolver.getNextDiscoveryState,
+            hasGetOnDeployNextDiscoveryState: true,
+        }
+        : {}));
+};
+const convertInput = (key, definition) => {
+    // Cast: the field union is wider than any single member; runtime guards below handle it.
+    const _a = definition, { default: defaultValue, type, label, collection, inputs: childInputs, configurations } = _a, rest = __rest(_a, ["default", "type", "label", "collection", "inputs", "configurations"]);
     const keyLabel = collection === "keyvaluelist" && typeof label === "object" ? label.key : undefined;
+    const nestedInputs = type === "structuredObject" && childInputs
+        ? Object.entries(childInputs).map(([childKey, childDef]) => (0, exports.convertInput)(childKey, childDef))
+        : type === "dynamicObject" && configurations
+            ? Object.entries(configurations).map(([configKey, configDef]) => ({
+                key: configKey,
+                type: "structuredObject",
+                label: typeof configDef.label === "string" ? configDef.label : configDef.label.value,
+                comments: configDef.comments,
+                inputs: Object.entries(configDef.inputs).map(([childKey, childDef]) => (0, exports.convertInput)(childKey, childDef)),
+            }))
+            : undefined;
     return Object.assign(Object.assign({}, (0, omit_1.default)(rest, [
         "onPremControlled",
         "permissionAndVisibilityType",
         "visibleToOrgDeployer",
         "writeOnly",
     ])), { key,
-        type, default: defaultValue !== null && defaultValue !== void 0 ? defaultValue : types_1.InputFieldDefaultMap[type], collection, label: typeof label === "string" ? label : label.value, keyLabel, onPremiseControlled: ("onPremControlled" in rest && rest.onPremControlled) || undefined });
+        type, default: defaultValue !== null && defaultValue !== void 0 ? defaultValue : types_1.InputFieldDefaultMap[type], collection, label: typeof label === "string" ? label : label.value, keyLabel, onPremiseControlled: rest.onPremControlled === true ? true : undefined, inputs: nestedInputs });
 };
 exports.convertInput = convertInput;
 const TEMPLATE_VALUE_REGEX = /{{#(\w+)}}/g;
@@ -73,28 +207,53 @@ exports.convertTemplateInput = convertTemplateInput;
 const convertAction = (actionKey, _a, hooks) => {
     var { inputs = {}, perform } = _a, action = __rest(_a, ["inputs", "perform"]);
     const convertedInputs = Object.entries(inputs).map(([key, value]) => (0, exports.convertInput)(key, value));
-    const inputCleaners = Object.entries(inputs).reduce((result, [key, { clean }]) => (Object.assign(Object.assign({}, result), { [key]: clean })), {});
+    const inputCleaners = Object.entries(inputs).reduce((result, [key, value]) => (Object.assign(Object.assign({}, result), { [key]: (0, exports.cleanerFor)(value) })), {});
     return Object.assign(Object.assign({}, action), { key: actionKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
             inputCleaners,
             errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
         }) });
 };
-const convertTrigger = (triggerKey, trigger, hooks) => {
+const convertTrigger = (triggerKey, 
+// `any` is load-bearing: the user-facing TriggerDefinition / PollingTriggerDefinition
+// type their event-function fields (onInstanceDeploy, webhookLifecycleHandlers, etc.) over
+// TInputs/TConfigVars/TPayload, while the wire-format ServerTrigger drops those generics.
+// The `...trigger` spread in the result construction below would surface variance errors
+// without these `any`s. The user-typed handlers are immediately replaced with
+// createPerform-wrapped versions, so the loose input typing is safe in practice.
+trigger, hooks) => {
     var _a;
     const { onInstanceDeploy, onInstanceDelete } = trigger;
     const webhookLifecycleHandlers = "webhookLifecycleHandlers" in trigger ? trigger.webhookLifecycleHandlers : undefined;
     const inputs = (_a = trigger.inputs) !== null && _a !== void 0 ? _a : {};
-    const isPollingTrigger = (0, PollingTriggerDefinition_1.isPollingTriggerDefinition)(trigger);
     const triggerInputKeys = Object.keys(inputs);
     const convertedTriggerInputs = Object.entries(inputs).map(([key, value]) => {
         return (0, exports.convertInput)(key, value);
     });
-    const triggerInputCleaners = Object.entries(inputs).reduce((result, [key, { clean }]) => (Object.assign(Object.assign({}, result), { [key]: clean })), {});
+    const triggerInputCleaners = Object.entries(inputs).reduce((result, [key, value]) => (Object.assign(Object.assign({}, result), { [key]: (0, exports.cleanerFor)(value) })), {});
     let scheduleSupport = "scheduleSupport" in trigger ? trigger.scheduleSupport : "invalid";
+    const batchConfig = "batchConfig" in trigger ? trigger.batchConfig : undefined;
+    const triggerResolver = "triggerResolver" in trigger ? trigger.triggerResolver : undefined;
+    const triggerResolverSupport = "triggerResolverSupport" in trigger && trigger.triggerResolverSupport !== undefined
+        ? trigger.triggerResolverSupport
+        : triggerResolver
+            ? "valid"
+            : "invalid";
+    if (triggerResolverSupport === "required" && !triggerResolver) {
+        throw new Error(`Trigger "${trigger.display.label}" declares triggerResolverSupport "required" but is missing triggerResolver.`);
+    }
+    if (triggerResolverSupport === "invalid" && triggerResolver) {
+        throw new Error(`Trigger "${trigger.display.label}" declares triggerResolver but triggerResolverSupport is "invalid".`);
+    }
+    const onDeployPerform = "onDeployPerform" in trigger ? trigger.onDeployPerform : undefined;
+    const onDeployResolver = "onDeployResolver" in trigger ? trigger.onDeployResolver : undefined;
+    // On-deploy is presence-driven (no support flag): a trigger that defines an
+    // `onDeployResolver` must also define the `onDeployPerform` fire it batches.
+    if ((onDeployResolver === null || onDeployResolver === void 0 ? void 0 : onDeployResolver.resolveItems) && !onDeployPerform) {
+        throw new Error(`Trigger "${trigger.display.label}" declares onDeployResolver.resolveItems but is missing onDeployPerform.`);
+    }
     let convertedActionInputs = [];
     let performToUse;
-    if (isPollingTrigger) {
-        // Pull inputs up from the action and make them available on the trigger
+    if ((0, PollingTriggerDefinition_1.isPollingTriggerDefinition)(trigger)) {
         const { pollAction: action } = trigger;
         let actionInputCleaners = {};
         scheduleSupport = "required";
@@ -106,7 +265,7 @@ const convertTrigger = (triggerKey, trigger, hooks) => {
                 accum.push((0, exports.convertInput)(key, value));
                 return accum;
             }, []);
-            actionInputCleaners = Object.entries(action.inputs).reduce((result, [key, { clean }]) => (Object.assign(Object.assign({}, result), { [key]: clean })), {});
+            actionInputCleaners = Object.entries(action.inputs).reduce((result, [key, value]) => (Object.assign(Object.assign({}, result), { [key]: (0, exports.cleanerFor)(value) })), {});
         }
         const combinedCleaners = Object.assign({}, actionInputCleaners, triggerInputCleaners);
         performToUse = (0, perform_1.createPollingPerform)(trigger, {
@@ -120,11 +279,11 @@ const convertTrigger = (triggerKey, trigger, hooks) => {
             errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
         });
     }
-    const result = Object.assign(Object.assign(Object.assign({}, trigger), { key: triggerKey, inputs: convertedTriggerInputs.concat(convertedActionInputs), perform: performToUse, scheduleSupport, synchronousResponseSupport: "synchronousResponseSupport" in trigger
+    const result = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, (0, omit_1.default)(trigger, ["batchConfig", "triggerResolver", "onDeployResolver"])), { key: triggerKey, inputs: convertedTriggerInputs.concat(convertedActionInputs), perform: performToUse, scheduleSupport, synchronousResponseSupport: "synchronousResponseSupport" in trigger
             ? trigger.synchronousResponseSupport
             : scheduleSupport === "invalid"
                 ? "valid"
-                : "invalid" }), (isPollingTrigger ? { isPollingTrigger: true } : {}));
+                : "invalid", triggerResolverSupport }), buildBatchDefaultField(trigger.display.label, triggerResolverSupport, !!(onDeployResolver === null || onDeployResolver === void 0 ? void 0 : onDeployResolver.resolveItems), batchConfig)), buildTriggerResolverFields(triggerResolver)), buildOnDeployResolverFields(onDeployResolver)), ((0, PollingTriggerDefinition_1.isPollingTriggerDefinition)(trigger) ? { isPollingTrigger: true } : {}));
     if (onInstanceDeploy) {
         result.onInstanceDeploy = (0, perform_1.createPerform)(onInstanceDeploy, {
             inputCleaners: triggerInputCleaners,
@@ -132,6 +291,13 @@ const convertTrigger = (triggerKey, trigger, hooks) => {
         });
         result.hasOnInstanceDeploy = true;
     }
+    if (onDeployPerform) {
+        result.onDeployPerform = (0, perform_1.createPerform)(onDeployPerform, {
+            inputCleaners: triggerInputCleaners,
+            errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,
+        });
+        result.hasOnDeployPerform = true;
+    }
     if (onInstanceDelete) {
         result.onInstanceDelete = (0, perform_1.createPerform)(onInstanceDelete, {
             inputCleaners: triggerInputCleaners,
@@ -158,7 +324,7 @@ exports.convertTrigger = convertTrigger;
 const convertDataSource = (dataSourceKey, _a, hooks) => {
     var { inputs = {}, perform } = _a, dataSource = __rest(_a, ["inputs", "perform"]);
     const convertedInputs = Object.entries(inputs).map(([key, value]) => (0, exports.convertInput)(key, value));
-    const inputCleaners = Object.entries(inputs).reduce((result, [key, { clean }]) => (Object.assign(Object.assign({}, result), { [key]: clean })), {});
+    const inputCleaners = Object.entries(inputs).reduce((result, [key, value]) => (Object.assign(Object.assign({}, result), { [key]: (0, exports.cleanerFor)(value) })), {});
     return Object.assign(Object.assign({}, dataSource), { key: dataSourceKey, inputs: convertedInputs, perform: (0, perform_1.createPerform)(perform, {
             inputCleaners,
             errorHandler: hooks === null || hooks === void 0 ? void 0 : hooks.error,