@prismatic-io/spectral 10.12.2 → 10.14.0

package/dist/generators/cniComponentManifest/index.d.ts

@@ -1,5 +1,6 @@
+import type { Inputs, ConfigVarResultCollection, TriggerPayload, TriggerResult } from "../../types";
 import { FormattedAction, FormattedDataSource, FormattedTrigger } from "./types";
-export declare const fetchComponentDataForManifest: ({ componentKey, isPrivate, }: {
+export declare const fetchComponentDataForManifest: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ componentKey, isPrivate, }: {
     componentKey: string;
     isPrivate: boolean;
 }) => Promise<{
@@ -11,7 +12,7 @@ export declare const fetchComponentDataForManifest: ({ componentKey, isPrivate,
         description: string;
     };
     actions: Record<string, FormattedAction>;
-    triggers: Record<string, FormattedTrigger>;
+    triggers: Record<string, FormattedTrigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>>;
     dataSources: Record<string, FormattedDataSource>;
     connections: {
         key: string;

package/dist/generators/cniComponentManifest/types.d.ts

@@ -1,4 +1,6 @@
-import { Action, Component, DataSource, Trigger } from "../../serverTypes";
+import { Action, Component, DataSource, Trigger, TriggerPayload } from "../../serverTypes";
+import { ConfigVarResultCollection, Inputs } from "../../types";
+import { TriggerResult } from "../../types/TriggerResult";
 export interface ComponentNode {
     id: string;
     label: string;
@@ -46,11 +48,11 @@ export interface InputNode {
     onPremiseControlled: boolean;
 }
 export type FormattedAction = Pick<Action, "key" | "display" | "inputs" | "examplePayload">;
-export type FormattedTrigger = Pick<Trigger, "key" | "display" | "inputs">;
+export type FormattedTrigger<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> = Pick<Trigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>, "key" | "display" | "inputs">;
 export type FormattedDataSource = Pick<DataSource, "key" | "display" | "inputs" | "dataSourceType" | "examplePayload">;
-export type ComponentForManifest = Pick<Component, "key" | "public" | "display" | "connections"> & {
+export type ComponentForManifest<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> = Pick<Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>, "key" | "public" | "display" | "connections"> & {
     actions: Record<string, Action | FormattedAction>;
-    triggers: Record<string, Trigger | FormattedTrigger>;
+    triggers: Record<string, Trigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult> | FormattedTrigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>>;
     dataSources: Record<string, DataSource | FormattedDataSource>;
 };
 export type ComponentActionsQueryResponse = {

package/dist/generators/componentManifest/createActions.d.ts

@@ -1,12 +1,13 @@
 import type { ComponentForManifest } from "../cniComponentManifest/types";
-interface CreateActionsProps {
-    component: ComponentForManifest;
+import { Inputs, ConfigVarResultCollection, TriggerPayload, TriggerResult } from "../../types";
+interface CreateActionsProps<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> {
+    component: ComponentForManifest<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
     dryRun: boolean;
     verbose: boolean;
     sourceDir: string;
     destinationDir: string;
 }
-export declare const createActions: ({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateActionsProps) => Promise<{
+export declare const createActions: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateActionsProps<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>) => Promise<{
     actionIndex: string | void;
     actions: (string | void)[];
 }>;

package/dist/generators/componentManifest/createConnections.d.ts

@@ -1,12 +1,13 @@
 import type { ComponentForManifest } from "../cniComponentManifest/types";
-interface CreateConnectionsProps {
-    component: ComponentForManifest;
+import { Inputs, ConfigVarResultCollection, TriggerPayload, TriggerResult } from "../../types";
+interface CreateConnectionsProps<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> {
+    component: ComponentForManifest<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
     dryRun: boolean;
     verbose: boolean;
     sourceDir: string;
     destinationDir: string;
 }
-export declare const createConnections: ({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateConnectionsProps) => Promise<{
+export declare const createConnections: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateConnectionsProps<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>) => Promise<{
     connectionIndex: string | void;
     connections: (string | void)[];
 }>;

package/dist/generators/componentManifest/createDataSources.d.ts

@@ -1,12 +1,13 @@
 import type { ComponentForManifest } from "../cniComponentManifest/types";
-interface CreateDataSourcesProps {
-    component: ComponentForManifest;
+import { Inputs, ConfigVarResultCollection, TriggerPayload, TriggerResult } from "../../types";
+interface CreateDataSourcesProps<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> {
+    component: ComponentForManifest<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
     dryRun: boolean;
     verbose: boolean;
     sourceDir: string;
     destinationDir: string;
 }
-export declare const createDataSources: ({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateDataSourcesProps) => Promise<{
+export declare const createDataSources: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateDataSourcesProps<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>) => Promise<{
     dataSourceIndex: string | void;
     dataSources: (string | void)[];
 }>;

package/dist/generators/componentManifest/createStaticFiles.d.ts

@@ -1,11 +1,12 @@
 import type { Component } from "../../serverTypes";
+import { Inputs, ConfigVarResultCollection, TriggerPayload, TriggerResult } from "../../types";
 export interface PackageDependencies {
     spectral: string;
     dependencies: Record<string, string>;
     devDependencies: Record<string, string>;
 }
-interface CreateStaticFilesProps {
-    component: Component;
+interface CreateStaticFilesProps<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> {
+    component: Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
     dryRun: boolean;
     signature: string | null;
     packageName: string;
@@ -15,7 +16,7 @@ interface CreateStaticFilesProps {
     destinationDir: string;
     registry: string | null;
 }
-export declare const createStaticFiles: ({ component, dryRun, signature, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }: CreateStaticFilesProps) => Promise<{
+export declare const createStaticFiles: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ component, dryRun, signature, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }: CreateStaticFilesProps<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>) => Promise<{
     index: string | void;
     packageJson: string | void;
     tsConfig: string | void;

package/dist/generators/componentManifest/createTriggers.d.ts

@@ -1,12 +1,13 @@
 import type { ComponentForManifest } from "../cniComponentManifest/types";
-interface CreateTriggersProps {
-    component: ComponentForManifest;
+import { Inputs, ConfigVarResultCollection, TriggerPayload, TriggerResult } from "../../types";
+interface CreateTriggersProps<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> {
+    component: ComponentForManifest<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
     dryRun: boolean;
     verbose: boolean;
     sourceDir: string;
     destinationDir: string;
 }
-export declare const createTriggers: ({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateTriggersProps) => Promise<{
+export declare const createTriggers: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ component, dryRun, verbose, sourceDir, destinationDir, }: CreateTriggersProps<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>) => Promise<{
     triggersIndex: string | void;
     triggers: (string | void)[];
 }>;

package/dist/generators/componentManifest/index.d.ts

@@ -1,7 +1,8 @@
 import { type PackageDependencies } from "./createStaticFiles";
 import type { Component } from "../../serverTypes";
-interface CreateComponentManifestProps {
-    component: Component;
+import { Inputs, ConfigVarResultCollection, TriggerPayload, TriggerResult } from "../../types";
+interface CreateComponentManifestProps<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> {
+    component: Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
     dryRun: boolean;
     skipSignatureVerify: boolean;
     packageName: string;
@@ -11,5 +12,5 @@ interface CreateComponentManifestProps {
     destinationDir: string;
     registry: string | null;
 }
-export declare const createComponentManifest: ({ component, dryRun, skipSignatureVerify, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }: CreateComponentManifestProps) => Promise<void>;
+export declare const createComponentManifest: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ component, dryRun, skipSignatureVerify, packageName, dependencies, verbose, sourceDir, destinationDir, registry, }: CreateComponentManifestProps<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>) => Promise<void>;
 export {};

package/dist/index.d.ts

@@ -16,7 +16,7 @@ import type { PollingTriggerDefinition } from "./types/PollingTriggerDefinition"
  * @param definition An IntegrationDefinition type object.
  * @returns This function returns an integration object that has the shape the Prismatic API expects.
  */
-export declare const integration: <T extends IntegrationDefinition = IntegrationDefinition>(definition: T) => ReturnType<typeof convertIntegration>;
+export declare const integration: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, T extends IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult> = IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>>(definition: T) => ReturnType<typeof convertIntegration<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>>;
 /**
  * This function creates a flow object for use in code-native integrations.
  * For information on writing code-native flows, see
@@ -25,7 +25,7 @@ export declare const integration: <T extends IntegrationDefinition = Integration
  * @param definition A Flow type object.
  * @returns This function returns a flow object that has the shape the Prismatic API expects.
  */
-export declare const flow: <TTriggerPayload extends TriggerPayload = TriggerPayload, T extends Flow<TTriggerPayload> = Flow<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, T extends Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload> = Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload>>(definition: T) => T;
 /**
  * This function creates a config wizard page object for use in code-native
  * integrations. For information on code-native config wizards, see

package/dist/serverTypes/asyncContext.d.ts

@@ -1,9 +1,9 @@
-import { ComponentRegistry, IntegrationDefinition } from "../types";
+import { ComponentRegistry, IntegrationDefinition, Inputs, TriggerPayload, TriggerResult } from "../types";
 import type { ActionContext } from "../types/ActionPerformFunction";
 export declare function runWithContext<T>(context: ActionContext, fn: () => T | Promise<T>): T | Promise<T>;
 export declare function requireContext(): ActionContext;
-export declare function runWithIntegrationContext<T extends IntegrationDefinition, U>(context: T, fn: () => U): U;
-export declare function requireIntegrationContext<T extends IntegrationDefinition>(): T;
+export declare function runWithIntegrationContext<TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, T extends IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult> = IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>, U = unknown>(context: T, fn: () => U): U;
+export declare function requireIntegrationContext<TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, T extends IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult> = IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>>(): T;
 type GetUserDefinedKeyByComponentKey<K extends string, T extends ComponentRegistry, TPublic extends boolean> = keyof T extends infer UserKey ? UserKey extends keyof T ? T[UserKey] extends {
     key: string;
     public: boolean;

package/dist/serverTypes/context.d.ts

@@ -1,6 +1,6 @@
 import { ActionContext as ServerActionContext } from ".";
-import { ActionContext, ComponentRegistry, DebugContext, FlowInvoker } from "../types";
-export declare function createCNIContext(context: ActionContext, componentRegistry: ComponentRegistry): ActionContext;
+import { ActionContext, ComponentRegistry, DebugContext, FlowInvoker, ConfigVarResultCollection, ComponentManifest } from "../types";
+export declare function createCNIContext<TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TComponentActions extends Record<string, ComponentManifest["actions"]> = Record<string, ComponentManifest["actions"]>, TFlows extends string[] = string[]>(context: ActionContext<TConfigVars, TComponentActions, TFlows>, componentRegistry: ComponentRegistry): ActionContext<TConfigVars, TComponentActions, TFlows>;
 export declare function createDebugContext(context: ServerActionContext): DebugContext;
 export declare function logDebugResults(context: ActionContext): void;
 export declare const createInvokeFlow: <const TFlows extends Readonly<string[]>>(context: ActionContext, options?: {

package/dist/serverTypes/convertComponent.d.ts

@@ -1,4 +1,4 @@
-import { InputFieldDefinition, ComponentDefinition, ConnectionDefinition, TriggerDefinition, ComponentHooks, ConfigVarResultCollection, OnPremConnectionInput, TriggerPayload, ConnectionTemplateInputField, ConnectionInput } from "../types";
+import { InputFieldDefinition, ComponentDefinition, ConnectionDefinition, Inputs, TriggerDefinition, ComponentHooks, ConfigVarResultCollection, OnPremConnectionInput, TriggerPayload, ConnectionTemplateInputField, ConnectionInput, TriggerResult } from "../types";
 import { Component as ServerComponent, Connection as ServerConnection, Trigger as ServerTrigger, Input as ServerInput } from ".";
 import { PollingTriggerDefinition } from "../types/PollingTriggerDefinition";
 export declare const convertInput: (key: string, { default: defaultValue, type, label, collection, ...rest }: InputFieldDefinition | OnPremConnectionInput | ConnectionInput) => ServerInput;
@@ -11,6 +11,6 @@ export declare const _isValidTemplateValue: (template: string, inputs: {
 export declare const convertTemplateInput: (key: string, { templateValue, label, ...rest }: ConnectionTemplateInputField, inputs: {
     [key: string]: ConnectionInput | ConnectionTemplateInputField;
 }) => ServerInput;
-export declare const convertTrigger: (triggerKey: string, trigger: TriggerDefinition<any> | PollingTriggerDefinition<any, ConfigVarResultCollection, TriggerPayload, boolean, any, any>, hooks?: ComponentHooks) => ServerTrigger;
+export declare const convertTrigger: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>(triggerKey: string, trigger: TriggerDefinition<any> | PollingTriggerDefinition<any, ConfigVarResultCollection, TriggerPayload, boolean, any, any>, hooks?: ComponentHooks) => ServerTrigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
 export declare const convertConnection: ({ inputs, ...connection }: ConnectionDefinition) => ServerConnection;
-export declare const convertComponent: <TPublic extends boolean, TKey extends string>({ connections, actions, triggers, dataSources, hooks, ...definition }: ComponentDefinition<TPublic, TKey>) => ServerComponent;
+export declare const convertComponent: <TPublic extends boolean, TKey extends string, TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ connections, actions, triggers, dataSources, hooks, ...definition }: ComponentDefinition<TPublic, TKey>) => ServerComponent<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;

package/dist/serverTypes/convertIntegration.d.ts

@@ -1,11 +1,29 @@
-import { IntegrationDefinition, ConfigVar, Flow, ConfigPages, ComponentRegistry, CollectionType } from "../types";
-import { Component as ServerComponent } from ".";
-import { RequiredConfigVariable as ServerRequiredConfigVariable, ConfigPage as ServerConfigPage } from "./integration";
-export declare const convertIntegration: (definition: IntegrationDefinition) => ServerComponent;
+import { IntegrationDefinition, ConfigVar, Flow, ConfigPages, ComponentRegistry, TriggerReference, CollectionType, Inputs, TriggerResult as TriggerPerformResult, ConfigVarResultCollection } from "../types";
+import { Component as ServerComponent, ActionContext, TriggerPayload, TriggerResult } from ".";
+import { RequiredConfigVariable as ServerRequiredConfigVariable, ConfigPage as ServerConfigPage, ComponentReference as ServerComponentReference } from "./integration";
+export declare const convertIntegration: <TInputs extends Inputs, TActionInputs extends Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerPerformResult<TAllowsBranching, TPayload> = TriggerPerformResult<TAllowsBranching, TPayload>>(definition: IntegrationDefinition<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>) => ServerComponent<TInputs, TActionInputs, ConfigVarResultCollection, TPayload, TAllowsBranching, TResult>;
 export declare const convertConfigPages: (pages: ConfigPages | undefined, userLevelConfigured: boolean) => ServerConfigPage[];
 /** Converts a Flow into the structure necessary for YAML generation. */
-export declare const convertFlow: (flow: Flow, 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>>(flow: 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. */
 export declare const convertConfigVar: (key: string, configVar: ConfigVar, referenceKey: string, componentRegistry: ComponentRegistry) => ServerRequiredConfigVariable;
+export declare const invokeTriggerComponentInput: (componentRef: ServerComponentReference, onTrigger: TriggerReference | undefined, eventName: "perform" | "onInstanceDeploy" | "onInstanceDelete") => {
+    component: {
+        key: string;
+        version: number | "LATEST";
+        isPublic: boolean;
+    } | {
+        key: string;
+        signature: string;
+        isPublic: boolean;
+    };
+    key: string;
+    triggerEventFunctionName: "perform" | "onInstanceDeploy" | "onInstanceDelete";
+};
+export type TriggerActionInvokeFunction = (ref: {
+    component: ServerComponentReference["component"];
+    key: string;
+    triggerEventFunctionName: "perform" | "onInstanceDeploy" | "onInstanceDelete";
+}, context: ActionContext, payload: TriggerPayload | null, params: Record<string, unknown>) => Promise<TriggerResult>;

package/dist/serverTypes/convertIntegration.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertConfigVar = exports.convertInputValue = exports.convertFlow = exports.convertConfigPages = exports.convertIntegration = void 0;
+exports.invokeTriggerComponentInput = exports.convertConfigVar = exports.convertInputValue = exports.convertFlow = exports.convertConfigPages = exports.convertIntegration = void 0;
 const yaml_1 = __importDefault(require("yaml"));
 const uuid_1 = require("uuid");
 const assign_1 = __importDefault(require("lodash/assign"));
@@ -20,6 +20,7 @@ const camelCase_1 = __importDefault(require("lodash/camelCase"));
 const pick_1 = __importDefault(require("lodash/pick"));
 const types_1 = require("../types");
 const convertComponent_1 = require("./convertComponent");
+const perform_1 = require("./perform");
 const integration_1 = require("./integration");
 const merge_1 = __importDefault(require("lodash/merge"));
 const context_1 = require("./context");
@@ -306,6 +307,7 @@ const convertFlow = (flow, componentRegistry, referenceKey) => {
     result.preprocessFlowConfig = undefined;
     result.errorConfig = undefined;
     result.testApiKeys = undefined;
+    result.triggerType = undefined;
     let publicSupplementalComponent;
     const triggerStep = {
         name: "On Trigger",
@@ -358,6 +360,9 @@ const convertFlow = (flow, componentRegistry, referenceKey) => {
         result.schedule = undefined;
         hasSchedule = true;
     }
+    if (flow.triggerType === "polling" && !hasSchedule) {
+        throw new Error(`${flow.name} is marked as a polling trigger but has no schedule. Polling triggers require a schedule.`);
+    }
     if ("queueConfig" in flow && typeof flow.queueConfig === "object") {
         const { queueConfig } = flow;
         if (hasSchedule && queueConfig.usesFifoQueue) {
@@ -369,6 +374,10 @@ const convertFlow = (flow, componentRegistry, referenceKey) => {
         else if (queueConfig.usesFifoQueue && queueConfig.singletonExecutions) {
             throw new Error(`${flow.name} is configured for both FIFO queues and singleton executions, but these options are mutually exclusive. Please choose one.`);
         }
+        if (queueConfig.concurrencyLimit !== undefined &&
+            (queueConfig.concurrencyLimit < 2 || queueConfig.concurrencyLimit > 10)) {
+            throw new Error(`${flow.name} has an invalid concurrencyLimit of ${queueConfig.concurrencyLimit}. concurrencyLimit must be between 2 and 10.`);
+        }
         result.queueConfig = Object.assign(Object.assign({ usesFifoQueue: false }, queueConfig), (queueConfig.dedupeIdField
             ? {
                 dedupeIdField: {
@@ -408,6 +417,22 @@ const convertInputValue = (value, collectionType) => {
     }));
 };
 exports.convertInputValue = convertInputValue;
+const validateOnPremConnectionConfig = (connection) => {
+    if ((0, types_1.isConnectionDefinitionConfigVar)(connection)) {
+        const hasOnPremControlledInputs = Object.values(connection.inputs).some((value) => {
+            return "onPremControlled" in value && value.onPremControlled;
+        });
+        const { onPremConnectionConfig: config } = connection;
+        if (hasOnPremControlledInputs && !config) {
+            throw new Error(`Connection ${connection.stableKey} has onPremControlled inputs but no onPremConnectionConfig value set. Please set an onPremConnectionConfig value for the connection.`);
+        }
+        if (!hasOnPremControlledInputs && config && config !== "disallowed") {
+            throw new Error(`Connection ${connection.stableKey} has onPremConnectionConfig set but no onPremControlled inputs. The connection will not be valid without onPremControlled inputs (host, port).`);
+        }
+        return hasOnPremControlledInputs && config ? config : "disallowed";
+    }
+    return "disallowed";
+};
 /** Converts a Config Var into the structure necessary for YAML generation. */
 const convertConfigVar = (key, configVar, referenceKey, componentRegistry) => {
     var _a, _b, _c;
@@ -428,6 +453,7 @@ const convertConfigVar = (key, configVar, referenceKey, componentRegistry) => {
             description,
             key,
             dataType: "connection",
+            onPremiseConnectionConfig: validateOnPremConnectionConfig(configVar),
             connection: {
                 key: (0, camelCase_1.default)(key),
                 component: codeNativeIntegrationComponentReference(referenceKey),
@@ -570,25 +596,57 @@ const invokeTriggerComponentInput = (componentRef, onTrigger, eventName) => {
         triggerEventFunctionName: eventName,
     };
 };
+exports.invokeTriggerComponentInput = invokeTriggerComponentInput;
+/** Type guard to narrow trigger perform functions based on triggerType.
+ * Since TriggerPerformFunction and CodeNativePollingTriggerPerformFunction are
+ * structurally identical, TypeScript cannot distinguish them. This guard uses
+ * triggerType to narrow the function type. */
+const isStandardTriggerPerform = (fn, triggerType) => triggerType !== "polling";
+// Force incoming config into a discriminated union type to simplify downstream handling
+function validateTriggerPerformConfig(params) {
+    const { componentRef, onTrigger, componentRegistry, triggerType } = params;
+    if (componentRef && onTrigger && typeof onTrigger !== "function") {
+        return {
+            componentRef,
+            onTrigger,
+            triggerType: "component-ref",
+            componentRegistry,
+        };
+    }
+    else if (triggerType === "polling" && typeof onTrigger === "function") {
+        return {
+            componentRef: undefined,
+            onTrigger,
+            triggerType,
+            componentRegistry,
+        };
+    }
+    else if (typeof onTrigger === "function" && isStandardTriggerPerform(onTrigger, triggerType)) {
+        return {
+            componentRef: undefined,
+            onTrigger,
+            triggerType: "standard",
+            componentRegistry,
+        };
+    }
+    else {
+        throw new Error(`Invalid trigger configuration detected: ${JSON.stringify(params, null, 2)}`);
+    }
+}
 /* Generates a wrapper function that calls an existing component trigger's perform. */
-const generateTriggerPerformFn = (componentRef, onTrigger, componentRegistry) => {
-    const performFn = componentRef && typeof onTrigger !== "function"
-        ? (context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
-            var _a;
-            // @ts-expect-error: _components isn't part of the public API
-            const _components = (_a = context._components) !== null && _a !== void 0 ? _a : {
-                invokeTrigger: () => { },
-            };
-            const invokeTrigger = _components.invokeTrigger;
-            const cniContext = (0, context_1.createCNIContext)(context, componentRegistry);
-            return yield invokeTrigger(invokeTriggerComponentInput(componentRef, onTrigger, "perform"), cniContext, payload, params);
-        })
-        : (context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
-            const cniContext = (0, context_1.createCNIContext)(context, componentRegistry);
-            return yield onTrigger(cniContext, payload, params);
-        });
-    return performFn;
-};
+function generateTriggerPerformFn(params) {
+    const { componentRef, onTrigger, componentRegistry, triggerType } = validateTriggerPerformConfig(params);
+    switch (triggerType) {
+        case "polling":
+            return (0, perform_1.createCNIPollingPerform)({ onTrigger, componentRegistry });
+        case "standard":
+            return (0, perform_1.createCNIPerform)({ componentRegistry, onTrigger });
+        case "component-ref":
+            return (0, perform_1.createCNIComponentRefPerform)({ componentRegistry, componentRef, onTrigger });
+        default:
+            throw new Error(`Invalid trigger configuration detected: ${JSON.stringify(params, null, 2)}`);
+    }
+}
 /** Generates a wrapper function that calls an existing component's onInstanceDeploy
  * or onInstanceDelete, then calls the flow-defined version if it exists.
  * Returns the deep-merged results of the two, prioritizing the custom response
@@ -606,7 +664,7 @@ const generateOnInstanceWrapperFn = (componentRef, onTrigger, eventName, compone
             const cniContext = (0, context_1.createCNIContext)(context, componentRegistry);
             // Using runWithContext allows for component action invocation via manifest.
             return yield (0, asyncContext_1.runWithContext)(cniContext, () => __awaiter(void 0, void 0, void 0, function* () {
-                const invokeResponse = (yield invokeTrigger(invokeTriggerComponentInput(componentRef, onTrigger, eventName), cniContext, null, params)) || {};
+                const invokeResponse = (yield invokeTrigger((0, exports.invokeTriggerComponentInput)(componentRef, onTrigger, eventName), cniContext, null, params)) || {};
                 let customResponse = {};
                 if (customFn) {
                     customResponse = (yield customFn(cniContext, params)) || {};
@@ -639,7 +697,7 @@ 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 = [], componentRegistry = {}, }, referenceKey, configVars) => {
     const convertedActions = flows.reduce((result, { name, onExecution }) => {
         const key = flowFunctionKey(name, "onExecution");
         return Object.assign(Object.assign({}, result), { [key]: {
@@ -652,7 +710,7 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
                 inputs: [],
             } });
     }, {});
-    const convertedTriggers = flows.reduce((result, { name, onTrigger, onInstanceDeploy, onInstanceDelete, schedule }) => {
+    const convertedTriggers = flows.reduce((result, { name, onTrigger, onInstanceDeploy, onInstanceDelete, schedule, triggerType }) => {
         if (!flowUsesWrapperTrigger({
             onTrigger,
             onInstanceDelete,
@@ -676,7 +734,12 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
         const { ref } = (0, types_1.isComponentReference)(onTrigger)
             ? convertComponentReference(onTrigger, componentRegistry, "triggers")
             : { ref: onTrigger ? undefined : defaultComponentRef };
-        const performFn = generateTriggerPerformFn(ref, onTrigger, componentRegistry);
+        const performFn = generateTriggerPerformFn({
+            componentRef: ref,
+            onTrigger,
+            componentRegistry,
+            triggerType,
+        });
         const deleteFn = generateOnInstanceWrapperFn(ref, onTrigger, "onInstanceDelete", componentRegistry, onInstanceDelete);
         const deployFn = generateOnInstanceWrapperFn(ref, onTrigger, "onInstanceDeploy", componentRegistry, onInstanceDeploy);
         return Object.assign(Object.assign({}, result), { [key]: {
@@ -691,8 +754,9 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
                 onInstanceDelete: deleteFn,
                 hasOnInstanceDelete: !!deleteFn,
                 inputs: [],
-                scheduleSupport: "valid",
+                scheduleSupport: triggerType === "polling" ? "required" : "valid",
                 synchronousResponseSupport: "valid",
+                isPollingTrigger: triggerType === "polling",
             } });
     }, {});
     const convertedDataSources = Object.entries(configVars).reduce((result, [key, configVar]) => {

package/dist/serverTypes/index.d.ts

@@ -1,4 +1,5 @@
-import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection, ComponentManifest, FlowInvoker, ExecutionFrame, DebugContext, FlowSchemas } from "../types";
+import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection, ComponentManifest, FlowInvoker, ExecutionFrame, DebugContext, FlowSchemas, PollingTriggerPerformFunction, Inputs, TriggerResult as TriggerPerformResult, TriggerPerformFunction } from "../types";
+import type { CNIPollingPerformFunction, ComponentRefTriggerPerformFunction } from "./triggerTypes";
 interface DisplayDefinition {
     label: string;
     description: string;
@@ -15,7 +16,7 @@ export interface PublishingMetadata {
         testApiKeys?: string[];
     }[];
 }
-export interface Component {
+export interface Component<TInputs extends Inputs = Inputs, TActionInputs extends Inputs = Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerPerformResult<TAllowsBranching, TPayload> = TriggerPerformResult<TAllowsBranching, TPayload>> {
     key: string;
     public?: boolean;
     documentationUrl?: string;
@@ -24,7 +25,7 @@ export interface Component {
         iconPath?: string;
     };
     actions: Record<string, Action>;
-    triggers: Record<string, Trigger>;
+    triggers: Record<string, Trigger<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>>;
     dataSources: Record<string, DataSource>;
     connections: Connection[];
     codeNativeIntegrationYAML?: string;
@@ -130,10 +131,9 @@ interface TriggerBranchingResult extends TriggerBaseResult {
     branch: string;
 }
 export type TriggerResult = TriggerBranchingResult | TriggerBaseResult | undefined;
-export type TriggerPerformFunction = (context: ActionContext, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
 export type TriggerEventFunctionResult = TriggerEventFunctionReturn | void;
 export type TriggerEventFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
-export interface Trigger {
+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 & {
         directions?: string;
@@ -145,7 +145,7 @@ export interface Trigger {
     allowsBranching?: boolean;
     staticBranchNames?: string[];
     dynamicBranchInput?: string;
-    perform: TriggerPerformFunction;
+    perform: TriggerPerformFunction<TInputs, TConfigVars, TAllowsBranching, TResult> | PollingTriggerPerformFunction<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult> | CNIPollingPerformFunction<TInputs, TConfigVars, TPayload, TAllowsBranching> | ComponentRefTriggerPerformFunction<TInputs, TConfigVars>;
     onInstanceDeploy?: TriggerEventFunction;
     hasOnInstanceDeploy?: boolean;
     onInstanceDelete?: TriggerEventFunction;

package/dist/serverTypes/perform.d.ts

@@ -1,12 +1,35 @@
-import type { ConfigVarResultCollection, ErrorHandler, Inputs, PollingTriggerDefinition, PollingTriggerPerformFunction, TriggerPayload } from "../types";
+import type { ActionContext, ComponentRegistry, ConfigVarResultCollection, ErrorHandler, Inputs, PollingContext, PollingTriggerDefinition, PollingTriggerPerformFunction, TriggerPayload, TriggerReference, TriggerResult, TriggerPerformFunction } from "../types";
+import { ComponentReference as ServerComponentReference } from "./integration";
+import type { CNIPollingPerformFunction, ComponentRefTriggerPerformFunction } from "./triggerTypes";
 export type PerformFn = (...args: any[]) => Promise<any>;
+interface CreatePollingContext {
+    context: ActionContext;
+    invokeAction: PollingContext["polling"]["invokeAction"];
+}
+export declare const createPollingContext: ({ context, invokeAction, }: CreatePollingContext) => Pick<PollingContext, "polling">;
 export type CleanFn = (...args: any[]) => any;
 export type InputCleaners = Record<string, CleanFn | undefined>;
 interface CreatePerformProps {
     inputCleaners: InputCleaners;
     errorHandler?: ErrorHandler;
 }
-export declare const cleanParams: (params: Record<string, unknown>, cleaners: InputCleaners) => Record<string, any>;
+export declare const cleanParams: (params: Record<string, unknown>, cleaners: InputCleaners) => Record<string, unknown>;
 export declare const createPerform: (performFn: PerformFn, { inputCleaners, errorHandler }: CreatePerformProps) => PerformFn;
-export declare const createPollingPerform: (trigger: PollingTriggerDefinition<any, ConfigVarResultCollection, TriggerPayload, boolean, any, any>, { inputCleaners, errorHandler }: CreatePerformProps) => PollingTriggerPerformFunction<Inputs, Inputs>;
+export declare const createPollingPerform: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>(trigger: PollingTriggerDefinition<any, ConfigVarResultCollection, TriggerPayload, boolean, any, any>, { inputCleaners, errorHandler }: CreatePerformProps) => PollingTriggerPerformFunction<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
+type CreateCNIPollingPerform<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> = {
+    componentRegistry: ComponentRegistry;
+    onTrigger: PollingTriggerPerformFunction<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>;
+};
+export declare const createCNIPollingPerform: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>>({ onTrigger, componentRegistry, }: CreateCNIPollingPerform<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>) => CNIPollingPerformFunction<TInputs, TConfigVars, TPayload, TAllowsBranching>;
+interface CreateCNIComponentRefPerform {
+    componentRef: ServerComponentReference;
+    componentRegistry: ComponentRegistry;
+    onTrigger: TriggerReference;
+}
+export declare const createCNIComponentRefPerform: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection>({ componentRegistry, componentRef, onTrigger, }: CreateCNIComponentRefPerform) => ComponentRefTriggerPerformFunction<TInputs, TConfigVars>;
+interface CreateCNIPerform<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean | undefined, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>> {
+    componentRegistry: ComponentRegistry;
+    onTrigger: TriggerPerformFunction<TInputs, TConfigVars, TAllowsBranching, TResult>;
+}
+export declare const createCNIPerform: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean | undefined, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>>({ componentRegistry, onTrigger, }: CreateCNIPerform<TInputs, TConfigVars, TAllowsBranching, TResult>) => TriggerPerformFunction<TInputs, TConfigVars, TAllowsBranching, TResult>;
 export {};

package/dist/serverTypes/perform.js

@@ -23,9 +23,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPollingPerform = exports.createPerform = exports.cleanParams = void 0;
+exports.createCNIPerform = exports.createCNIComponentRefPerform = exports.createCNIPollingPerform = exports.createPollingPerform = exports.createPerform = exports.cleanParams = exports.createPollingContext = void 0;
+const convertIntegration_1 = require("./convertIntegration");
 const uniq_1 = __importDefault(require("lodash/uniq"));
 const context_1 = require("./context");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const createPollingContext = ({ context, invokeAction, }) => {
+    return {
+        polling: {
+            invokeAction,
+            getState: () => {
+                const internal = context.instanceState.__prismaticInternal;
+                const internalState = isRecord(internal) ? internal : {};
+                return isRecord(internalState.polling) ? internalState.polling : {};
+            },
+            setState: (newState) => {
+                const internal = context.instanceState.__prismaticInternal;
+                const internalState = isRecord(internal) ? internal : {};
+                context.instanceState.__prismaticInternal = Object.assign(Object.assign({}, internalState), { polling: newState });
+            },
+        },
+    };
+};
+exports.createPollingContext = createPollingContext;
 const cleanParams = (params, cleaners) => {
     const keys = (0, uniq_1.default)([...Object.keys(params), ...Object.keys(cleaners)]);
     return keys.reduce((result, key) => {
@@ -85,25 +105,10 @@ const createPollingPerform = (trigger, { inputCleaners, errorHandler }) => {
     return (context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
         try {
             const { pollAction } = trigger;
-            const pollingContext = {
-                invokeFlow: (0, context_1.createInvokeFlow)(context),
-                polling: {
-                    invokeAction: createInvokePollAction(context, pollAction, {
-                        errorHandler,
-                    }),
-                    getState: () => {
-                        var _a, _b;
-                        const castState = (_a = context.instanceState.__prismaticInternal) !== null && _a !== void 0 ? _a : {};
-                        return (_b = castState.polling) !== null && _b !== void 0 ? _b : {};
-                    },
-                    setState: (newState) => {
-                        var _a;
-                        const castState = (_a = context.instanceState.__prismaticInternal) !== null && _a !== void 0 ? _a : {};
-                        context.instanceState.__prismaticInternal = Object.assign(Object.assign({}, castState), { polling: newState });
-                    },
-                },
-                debug: (0, context_1.createDebugContext)(context),
-            };
+            const pollingContext = Object.assign(Object.assign({ invokeFlow: (0, context_1.createInvokeFlow)(context) }, (0, exports.createPollingContext)({
+                context,
+                invokeAction: createInvokePollAction(context, pollAction, { errorHandler }),
+            })), { debug: (0, context_1.createDebugContext)(context) });
             const triggerPerform = (0, exports.createPerform)(trigger.perform, {
                 inputCleaners,
                 errorHandler,
@@ -118,3 +123,42 @@ const createPollingPerform = (trigger, { inputCleaners, errorHandler }) => {
     });
 };
 exports.createPollingPerform = createPollingPerform;
+const createCNIPollingPerform = ({ onTrigger, componentRegistry, }) => {
+    return (context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
+        const cniContext = (0, context_1.createCNIContext)(context, componentRegistry);
+        const finalContext = Object.assign(Object.assign({}, cniContext), (0, exports.createPollingContext)({
+            context: cniContext,
+            invokeAction: () => __awaiter(void 0, void 0, void 0, function* () {
+                throw new Error("invokeAction is not available for code-native polling triggers. " +
+                    "Use getState/setState to manage polling state directly in your onTrigger function.");
+            }),
+        }));
+        const result = yield onTrigger(finalContext, payload, params);
+        if (result === undefined) {
+            return undefined;
+        }
+        const { polledNoChanges } = result, rest = __rest(result, ["polledNoChanges"]);
+        return Object.assign(Object.assign({}, rest), { resultType: polledNoChanges ? "polled_no_changes" : "completed" });
+    });
+};
+exports.createCNIPollingPerform = createCNIPollingPerform;
+const createCNIComponentRefPerform = ({ componentRegistry, componentRef, onTrigger, }) => {
+    return (context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        // @ts-expect-error: _components isn't part of the public API
+        const _components = (_a = context._components) !== null && _a !== void 0 ? _a : {
+            invokeTrigger: () => { },
+        };
+        const invokeTrigger = _components.invokeTrigger;
+        const cniContext = (0, context_1.createCNIContext)(context, componentRegistry);
+        return yield invokeTrigger((0, convertIntegration_1.invokeTriggerComponentInput)(componentRef, onTrigger, "perform"), cniContext, payload, params);
+    });
+};
+exports.createCNIComponentRefPerform = createCNIComponentRefPerform;
+const createCNIPerform = ({ componentRegistry, onTrigger, }) => {
+    return (context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
+        const cniContext = (0, context_1.createCNIContext)(context, componentRegistry);
+        return yield onTrigger(cniContext, payload, params);
+    });
+};
+exports.createCNIPerform = createCNIPerform;

package/dist/serverTypes/triggerTypes.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Trigger perform function types for server-side usage.
+ * These are separate from the user-facing types in ../types to avoid circular dependencies.
+ */
+import type { ActionContext, ActionInputParameters, ConfigVarResultCollection, Inputs, TriggerPayload, TriggerResult } from "../types";
+/** The result type after transforming a polling trigger result for the server. */
+export type PollingTriggerServerResult<TAllowsBranching extends boolean, TPayload extends TriggerPayload> = Omit<NonNullable<TriggerResult<TAllowsBranching, TPayload>>, "polledNoChanges"> & {
+    resultType: string;
+};
+/** The perform function type for CNI polling triggers that returns the server-expected format. */
+export type CNIPollingPerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean> = (context: ActionContext<TConfigVars>, payload: TPayload, params: ActionInputParameters<TInputs>) => Promise<PollingTriggerServerResult<TAllowsBranching, TPayload> | undefined>;
+/** Server trigger result type - matches the non-generic TriggerResult from serverTypes/index.ts */
+interface ServerTriggerBaseResult {
+    payload: TriggerPayload;
+    response?: {
+        statusCode: number;
+        contentType: string;
+        headers?: Record<string, string>;
+        body?: string;
+    };
+    instanceState?: Record<string, unknown>;
+    crossFlowState?: Record<string, unknown>;
+    executionState?: Record<string, unknown>;
+    integrationState?: Record<string, unknown>;
+    failed?: boolean;
+    error?: Record<string, unknown>;
+}
+interface ServerTriggerBranchingResult extends ServerTriggerBaseResult {
+    branch: string;
+}
+type ServerTriggerResult = ServerTriggerBranchingResult | ServerTriggerBaseResult | undefined;
+/** Return type for component ref triggers - uses the server's TriggerResult since we delegate to invokeTrigger. */
+export type ComponentRefTriggerPerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection> = (context: ActionContext<TConfigVars>, payload: TriggerPayload, params: ActionInputParameters<TInputs>) => Promise<ServerTriggerResult>;
+export {};

package/dist/serverTypes/triggerTypes.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Trigger perform function types for server-side usage.
+ * These are separate from the user-facing types in ../types to avoid circular dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/testing.d.ts

@@ -78,12 +78,12 @@ type ToTestValues<TConfigVars extends ConfigVarResultCollection> = {
  * Runs the Trigger and then the Action function and returns the result of the Action. See
  * https://prismatic.io/docs/integrations/triggers/cross-flow/#using-cross-flow-triggers-in-code-native
  */
-export declare const invokeFlow: <TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TConfigVarValues extends TestConfigVarValues = ToTestValues<TConfigVars>>(flow: Flow, { 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>, { configVars, context, payload, }?: {
     configVars?: TConfigVarValues;
     context?: Partial<ActionContext<TConfigVars>>;
     payload?: Partial<TriggerPayload>;
 }) => Promise<InvokeReturn<InvokeActionPerformReturn<false, unknown>>>;
-export declare class ComponentTestHarness<TComponent extends Component> {
+export declare class ComponentTestHarness<TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends InvokeTriggerResult<TAllowsBranching, TPayload> = InvokeTriggerResult<TAllowsBranching, TPayload>, TComponent extends Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult> = Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>> {
     component: TComponent;
     constructor(component: TComponent);
     private buildParams;
@@ -96,7 +96,7 @@ export declare class ComponentTestHarness<TComponent extends Component> {
      * Invoke a trigger by its key within a unit test. See
      * https://prismatic.io/docs/custom-connectors/unit-testing/
      */
-    trigger<TConfigVars extends ConfigVarResultCollection>(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<TriggerResult>;
+    trigger(key: string, payload?: Partial<TPayload>, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<TriggerResult>;
     /**
      * Invoke a trigger's onInstanceDeploy function by its key within a unit test. See
      * https://prismatic.io/docs/custom-connectors/unit-testing/
@@ -122,12 +122,12 @@ export declare class ComponentTestHarness<TComponent extends Component> {
  * Create a testing harness to test a custom component's actions, triggers and data sources. See
  * https://prismatic.io/docs/custom-connectors/unit-testing/
  */
-export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
+export declare const createHarness: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends InvokeTriggerResult<TAllowsBranching, TPayload> = InvokeTriggerResult<TAllowsBranching, TPayload>, TComponent extends Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult> = Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>>(component: TComponent) => ComponentTestHarness<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult, TComponent>;
 declare const _default: {
     loggerMock: () => ActionLogger;
     invoke: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform }: ActionDefinition<TInputs, TConfigVars, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext<TConfigVars>>) => Promise<InvokeReturn<TReturn>>;
     invokeTrigger: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching, TriggerPayload>>({ perform }: TriggerDefinition<TInputs, TConfigVars, TAllowsBranching, TResult>, context?: Partial<ActionContext<TConfigVars>>, payload?: TriggerPayload, params?: ActionInputParameters<TInputs>) => Promise<InvokeReturn<TResult>>;
-    createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
+    createHarness: <TInputs extends Inputs, TActionInputs extends Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends InvokeTriggerResult<TAllowsBranching, TPayload> = InvokeTriggerResult<TAllowsBranching, TPayload>, TComponent extends Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult> = Component<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult>>(component: TComponent) => ComponentTestHarness<TInputs, TActionInputs, TConfigVars, TPayload, TAllowsBranching, TResult, TComponent>;
     invokeDataSource: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TDataSourceType extends DataSourceType>({ perform }: DataSourceDefinition<TInputs, TConfigVars, TDataSourceType>, params: ActionInputParameters<TInputs>, context?: Partial<DataSourceContext<TConfigVars>>) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 };
 export default _default;

package/dist/testing.js

@@ -312,7 +312,9 @@ class ComponentTestHarness {
     trigger(key, payload, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const trigger = this.component.triggers[key];
-            return trigger.perform(createActionContext(context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
+            return trigger.perform(
+            // @ts-expect-error -- Revisit if this should support polling
+            createActionContext(context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
         });
     }
     /**

package/dist/types/ConfigVars.d.ts

@@ -169,13 +169,14 @@ export type DataSourceConfigVar = DataSourceDefinitionConfigVar | DataSourceRefe
 type BaseConnectionConfigVar = BaseConfigVar & {
     dataType: "connection";
 };
+export type OnPremiseConnectionConfigTypeEnum = "allowed" | "disallowed" | "required";
 type ConnectionDefinitionConfigVar = ConnectionDefinition extends infer TConnectionDefinitionType extends ConnectionDefinition ? TConnectionDefinitionType extends infer TConnectionDefinition extends ConnectionDefinition ? BaseConnectionConfigVar & Omit<TConnectionDefinition, "inputs" | "display" | "key"> & {
     icons?: TConnectionDefinition["display"]["icons"];
+    onPremConnectionConfig?: OnPremiseConnectionConfigTypeEnum;
     inputs: {
         [Key in keyof TConnectionDefinition["inputs"]]: TConnectionDefinition["inputs"][Key] & ConfigVarInputVisibility;
     };
 } : never : never;
-type OnPremiseConnectionConfigTypeEnum = "allowed" | "disallowed" | "required";
 type ConnectionReferenceConfigVar = ComponentRegistryConnection extends infer TConnectionReference ? TConnectionReference extends ComponentRegistryConnection ? BaseConnectionConfigVar & {
     connection: TConnectionReference["reference"] & ("onPremAvailable" extends keyof TConnectionReference ? TConnectionReference["onPremAvailable"] extends true ? {
         template?: string;

package/dist/types/IntegrationDefinition.d.ts

@@ -5,6 +5,7 @@ import type { ConfigPages, UserLevelConfigPages } from "./ConfigPages";
 import type { ConfigVars } from "./ConfigVars";
 import type { FlowDefinitionFlowSchema } from "./FlowSchemas";
 import type { Inputs } from "./Inputs";
+import type { PollingTriggerPerformFunction } from "./PollingTriggerDefinition";
 import type { ScopedConfigVarMap } from "./ScopedConfigVars";
 import type { TriggerEventFunction } from "./TriggerEventFunction";
 import type { TriggerPayload } from "./TriggerPayload";
@@ -14,7 +15,7 @@ import type { TriggerResult } from "./TriggerResult";
  * Defines attributes of a code-native integration. See
  * https://prismatic.io/docs/integrations/code-native/
  */
-export type IntegrationDefinition = {
+export type IntegrationDefinition<TInputs extends Inputs = Inputs, TActionInputs extends Inputs = Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = boolean, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>> = {
     /** The unique name for this integration. */
     name: string;
     /** Description for this integration. */
@@ -46,7 +47,7 @@ export type IntegrationDefinition = {
      * Flows for this integration. See
      * https://prismatic.io/docs/integrations/code-native/flows/
      */
-    flows: Flow[];
+    flows: Flow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult>[];
     /**
      * Config wizard pages for this integration. See
      * https://prismatic.io/docs/integrations/code-native/config-wizard/
@@ -84,8 +85,8 @@ export type FlowExecutionContext = ActionContext<ConfigVars, {
     [Key in keyof ComponentRegistry]: ComponentRegistry[Key]["actions"];
 }>;
 export type FlowExecutionContextActions = FlowExecutionContext["components"];
-/** Defines attributes of a flow of a code-native integration. */
-export interface Flow<TTriggerPayload extends TriggerPayload = TriggerPayload> {
+/** Base properties shared by all flow types. */
+interface FlowBase<TTriggerPayload extends TriggerPayload = TriggerPayload> {
     /** The unique name for this flow. */
     name: string;
     /** A unique, unchanging value that is used to maintain identity for the flow even if the name changes. */
@@ -116,18 +117,12 @@ export interface Flow<TTriggerPayload extends TriggerPayload = TriggerPayload> {
      */
     organizationApiKeys?: string[];
     testApiKeys?: string[];
-    /** Schedule configuration that defines the frequency with which this flow will be automatically executed. */
-    schedule?: (ValueExpression<string> | ConfigVarExpression) & {
-        timezone?: string;
-    };
     /** Error handling configuration. */
     errorConfig?: StepErrorConfig;
     /** Optional schemas definitions for the flow. Currently only for use with AI agents. */
     schemas?: Record<string, FlowDefinitionFlowSchema> & {
         invoke: FlowDefinitionFlowSchema;
     };
-    /** Specifies the trigger function for this flow, which returns a payload and optional HTTP response. */
-    onTrigger?: TriggerReference | TriggerPerformFunction<Inputs, ConfigVars, false, TriggerResult<false, TTriggerPayload>>;
     /**
      * Specifies the function to execute when an instance of this integration is deployed. See
      * https://prismatic.io/docs/custom-connectors/triggers/#instance-deploy-and-delete-events-for-triggers
@@ -141,6 +136,37 @@ export interface Flow<TTriggerPayload extends TriggerPayload = TriggerPayload> {
     /** Specifies the main function for this flow which is run when this flow is invoked. */
     onExecution: FlowOnExecution<TTriggerPayload>;
 }
+export type StandardTriggerType = "standard";
+/** A standard flow with a webhook or scheduled trigger (non-polling). */
+interface StandardFlow<TInputs extends Inputs = Inputs, TPayload extends TriggerPayload = TriggerPayload, TAllowsBranching extends boolean = false, TResult extends TriggerResult<TAllowsBranching, TPayload> = TriggerResult<TAllowsBranching, TPayload>, TTriggerPayload extends TriggerPayload = TriggerPayload> extends FlowBase<TTriggerPayload> {
+    triggerType?: StandardTriggerType;
+    /** Schedule configuration that defines the frequency with which this flow will be automatically executed. */
+    schedule?: (ValueExpression<string> | ConfigVarExpression) & {
+        timezone?: string;
+    };
+    /** Specifies the trigger function for this flow, which returns a payload and optional HTTP response. */
+    onTrigger?: TriggerReference | TriggerPerformFunction<TInputs, ConfigVars, TAllowsBranching, TResult>;
+}
+export type PollingTriggerType = "polling";
+/** A polling flow that runs on a schedule and has access to polling context (getState/setState). */
+interface PollingFlow<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> extends FlowBase<TTriggerPayload> {
+    /**
+     * Type of trigger for this flow. A "polling" trigger runs on a schedule
+     * and can use context.polling.* functions. Requires schedule to be set.
+     */
+    triggerType: PollingTriggerType;
+    /** Schedule configuration that defines the frequency with which this flow will be automatically executed. Required for polling triggers. */
+    schedule: (ValueExpression<string> | ConfigVarExpression) & {
+        timezone?: string;
+    };
+    /**
+     * Specifies the trigger function for this flow.
+     */
+    onTrigger: PollingTriggerPerformFunction<TInputs, TActionInputs, ConfigVars, TPayload, TAllowsBranching, TResult>;
+}
+/** Defines attributes of a flow of a code-native integration. */
+export type 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> = StandardFlow<TInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload> | PollingFlow<TInputs, TActionInputs, TPayload, TAllowsBranching, TResult, TTriggerPayload>;
+export type FlowTriggerType = PollingTriggerType | StandardTriggerType;
 /** Defines attributes of a Preprocess flow Configuration used by a flow of an integration. */
 export type PreprocessFlowConfig = {
     /** Name of the field in the data payload returned by the Preprocess flow to use for a flow Name. */
@@ -161,14 +187,16 @@ export type RetryConfig = {
     /** Name of the field in the data payload returned by the flow's trigger to use as a Unique Request ID for retry request cancellation. */
     uniqueRequestIdField?: string;
 };
-/** Defines attributes of a retry configuration used by a flow of an integration. */
+/** Defines attributes of a queue configuration used by a flow of an integration. */
 export type QueueConfig = {
-    /** Determines whether the flow should be executed using FIFO ordering. Not valid for synchonous or scheduled flows. */
+    /** Determines whether the flow should be executed using FIFO ordering. Not valid for synchronous or scheduled flows. */
     usesFifoQueue?: boolean;
     /** Reference to the field in the flow's trigger return payload; used to determine whether to queue the execution. */
     dedupeIdField?: string;
     /** Determines whether the flow should be setup for singleton executions. Only valid for scheduled/polling trigger-based flows. */
     singletonExecutions?: boolean;
+    /** The maximum number of concurrent executions for this flow. Must be between 2 and 10. */
+    concurrencyLimit?: number;
 };
 /** Defines attributes of a step error configuration used to determine how to handle errors during flow step execution. */
 export type StepErrorConfig = {
@@ -189,3 +217,4 @@ export type EndpointType = "flow_specific" | "instance_specific" | "shared_insta
 export type EndpointSecurityType = "unsecured" | "customer_optional" | "customer_required" | "organization";
 /** Choices of Step Error Handlers that define the behavior when a step error occurs. */
 export type StepErrorHandlerType = "fail" | "ignore" | "retry";
+export {};

package/dist/types/PollingTriggerDefinition.d.ts

@@ -7,9 +7,9 @@ import type { ConfigVarResultCollection, Inputs } from "./Inputs";
 import type { TriggerEventFunction } from "./TriggerEventFunction";
 import type { TriggerPayload } from "./TriggerPayload";
 import type { TriggerResult } from "./TriggerResult";
-export interface PollingContext<TInputs extends Inputs = Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection> extends ActionContext<TConfigVars> {
+export interface PollingContext<TInputs extends Inputs = Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, ReturnData = unknown> extends ActionContext<TConfigVars> {
     polling: {
-        invokeAction: (params: ActionInputParameters<TInputs>) => Promise<ActionPerformReturn<boolean, any>>;
+        invokeAction: (params: ActionInputParameters<TInputs>) => Promise<ActionPerformReturn<boolean, ReturnData>>;
         getState: () => Record<string, unknown>;
         setState: (newState: Record<string, unknown>) => void;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "10.12.2",
+  "version": "10.14.0",
   "description": "Utility library for building Prismatic connectors and code-native integrations",
   "keywords": ["prismatic"],
   "main": "dist/index.js",