@prismatic-io/spectral 8.0.0-preview8 → 8.0.1

package/dist/serverTypes/convertIntegration.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertIntegration = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+const uuid_1 = require("uuid");
+const lodash_1 = require("lodash");
+const types_1 = require("../types");
+const convert_1 = require("./convert");
+const integration_1 = require("./integration");
+const convertIntegration = (definition) => {
+    var _a;
+    // Generate a unique reference key that will be used to reference the
+    // actions, triggers, data sources, and connections that are created
+    // inline as part of the integration definition.
+    const referenceKey = (0, uuid_1.v4)();
+    const configVars = Object.assign({}, ...Object.values((_a = definition.configPages) !== null && _a !== void 0 ? _a : {}).map(({ elements }) => elements));
+    return Object.assign(Object.assign({}, codeNativeIntegrationComponent(definition, referenceKey, configVars)), { codeNativeIntegrationYAML: codeNativeIntegrationYaml(definition, referenceKey, configVars) });
+};
+exports.convertIntegration = convertIntegration;
+const convertConfigPages = (pages) => {
+    return Object.entries(pages).map(([name, { tagline, elements }]) => ({
+        name,
+        tagline,
+        elements: Object.keys(elements).map((key) => ({
+            type: "configVar",
+            value: key,
+        })),
+    }));
+};
+const codeNativeIntegrationYaml = ({ name, description, category, documentation, version, labels, endpointType, triggerPreprocessFlowConfig, flows, configPages, }, referenceKey, configVars) => {
+    // Find the preprocess flow config on the flow, if one exists.
+    const preprocessFlows = flows.filter((flow) => flow.preprocessFlowConfig);
+    // Do some validation of preprocess flow configs.
+    if (preprocessFlows.length > 1) {
+        throw new Error("Only one flow may define a Preprocess Flow Config.");
+    }
+    if (preprocessFlows.length && triggerPreprocessFlowConfig) {
+        throw new Error("Integration must not define both a Trigger Preprocess Flow Config and a Preprocess Flow.");
+    }
+    const hasPreprocessFlow = preprocessFlows.length > 0;
+    const preprocessFlowConfig = hasPreprocessFlow
+        ? preprocessFlows[0].preprocessFlowConfig
+        : triggerPreprocessFlowConfig;
+    if ([types_1.EndpointType.InstanceSpecific, types_1.EndpointType.SharedInstance].includes(endpointType || types_1.EndpointType.FlowSpecific) &&
+        !preprocessFlowConfig) {
+        throw new Error("Integration with specified EndpointType must define either a Trigger Preprocess Flow Config or a Preprocess Flow.");
+    }
+    // Transform the IntegrationDefinition into the structure that is appropriate
+    // for generating YAML, which will then be used by the Prismatic API to import
+    // the integration as a Code Native Integration.
+    const result = {
+        definitionVersion: integration_1.DefinitionVersion,
+        isCodeNative: true,
+        name,
+        description,
+        category,
+        documentation,
+        version,
+        labels,
+        requiredConfigVars: Object.entries(configVars || {}).map(([key, configVar]) => convertConfigVar(key, configVar, referenceKey)),
+        endpointType,
+        preprocessFlowName: hasPreprocessFlow ? preprocessFlows[0].name : undefined,
+        externalCustomerIdField: fieldNameToReferenceInput(hasPreprocessFlow ? "onExecution" : "payload", preprocessFlowConfig === null || preprocessFlowConfig === void 0 ? void 0 : preprocessFlowConfig.externalCustomerIdField),
+        externalCustomerUserIdField: fieldNameToReferenceInput(hasPreprocessFlow ? "onExecution" : "payload", preprocessFlowConfig === null || preprocessFlowConfig === void 0 ? void 0 : preprocessFlowConfig.externalCustomerUserIdField),
+        flowNameField: fieldNameToReferenceInput(hasPreprocessFlow ? "onExecution" : "payload", preprocessFlowConfig === null || preprocessFlowConfig === void 0 ? void 0 : preprocessFlowConfig.flowNameField),
+        flows: flows.map((flow) => convertFlow(flow, referenceKey)),
+        configPages: convertConfigPages(configPages !== null && configPages !== void 0 ? configPages : {}),
+    };
+    return yaml_1.default.stringify(result);
+};
+/** Converts a Flow into the structure necessary for YAML generation. */
+const convertFlow = (flow, referenceKey) => {
+    const result = Object.assign({}, flow);
+    delete result.onTrigger;
+    delete result.trigger;
+    delete result.onInstanceDeploy;
+    delete result.onInstanceDelete;
+    delete result.onExecution;
+    delete result.preprocessFlowConfig;
+    delete result.errorConfig;
+    const triggerStep = {
+        name: "On Trigger",
+        stableKey: `${flow.stableKey}-onTrigger`,
+        description: "The function that will be executed by the flow to return an HTTP response.",
+        isTrigger: true,
+        errorConfig: "errorConfig" in flow ? Object.assign({}, flow.errorConfig) : undefined,
+        action: {
+            key: flowFunctionKey(flow.name, "onTrigger"),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        },
+    };
+    if ("schedule" in flow && typeof flow.schedule === "object") {
+        triggerStep.schedule = {
+            type: "cronExpression" in flow.schedule ? "value" : "configVar",
+            value: "cronExpression" in flow.schedule
+                ? flow.schedule.cronExpression
+                : flow.schedule.configVarKey,
+            meta: {
+                scheduleType: types_1.ScheduleType.Custom,
+                timeZone: flow.schedule.timeZone,
+            },
+        };
+        delete result.schedule;
+    }
+    const actionStep = {
+        action: {
+            key: flowFunctionKey(flow.name, "onExecution"),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        },
+        name: "On Execution",
+        stableKey: `${flow.stableKey}-onExecution`,
+        description: "The function that will be executed by the flow.",
+        errorConfig: "errorConfig" in flow ? Object.assign({}, flow.errorConfig) : undefined,
+    };
+    result.steps = [triggerStep, actionStep];
+    return result;
+};
+/** Converts a Config Var into the structure necessary for YAML generation. */
+const convertConfigVar = (key, configVar, referenceKey) => {
+    const meta = (0, lodash_1.pick)(configVar, [
+        "visibleToCustomerDeployer",
+        "visibleToOrgDeployer",
+    ]);
+    if ((0, types_1.isConnectionConfigVar)(configVar)) {
+        return Object.assign(Object.assign({}, (0, lodash_1.pick)(configVar, ["stableKey", "description", "orgOnly"])), { key, dataType: "connection", connection: {
+                component: { key: referenceKey, version: "LATEST", isPublic: false },
+                key: (0, lodash_1.camelCase)(key),
+            }, inputs: Object.entries(configVar.inputs).reduce((result, [key, input]) => {
+                if (!input.shown || !input.default) {
+                    return result;
+                }
+                return Object.assign(Object.assign({}, result), { [key]: { type: "value", value: input.default } });
+            }, {}), meta });
+    }
+    const result = (0, lodash_1.assign)({ meta, key }, (0, lodash_1.pick)(configVar, [
+        "stableKey",
+        "description",
+        "orgOnly",
+        "defaultValue",
+        "dataType",
+        "pickList",
+        "scheduleType",
+        "timeZone",
+        "codeLanguage",
+        "collectionType",
+    ]));
+    // Handle data sources.
+    if ((0, types_1.isDataSourceConfigVar)(configVar)) {
+        result.dataType = configVar.dataSourceType;
+        result.dataSource = {
+            key: (0, lodash_1.camelCase)(key),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        };
+    }
+    return result;
+};
+/** Maps the step name field to a fully qualified input. */
+const fieldNameToReferenceInput = (stepName, fieldName) => fieldName
+    ? { type: "reference", value: `${stepName}.results.${fieldName}` }
+    : undefined;
+/** Actions and Triggers will be scoped to their flow by combining the flow
+ *  name and the function name. This is to ensure that the keys are unique
+ *  on the resulting object, which will be turned into a Component. */
+const flowFunctionKey = (flowName, functionName) => {
+    const flowKey = flowName
+        .replace(/[^0-9a-zA-Z]+/g, " ")
+        .trim()
+        .split(" ")
+        .map((w, i) => i === 0
+        ? w.toLowerCase()
+        : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join("");
+    return `${flowKey}_${functionName}`;
+};
+/** Creates the structure necessary to import a Component as part of a
+ *  Code Native integration. */
+const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [], }, referenceKey, configVars) => {
+    const convertedActions = flows.reduce((result, { name, onExecution }) => {
+        const key = flowFunctionKey(name, "onExecution");
+        return Object.assign(Object.assign({}, result), { [key]: {
+                key,
+                display: {
+                    label: `${name} - onExecution`,
+                    description: "The function that will be executed by the flow.",
+                },
+                perform: onExecution,
+                inputs: [],
+            } });
+    }, {});
+    const convertedTriggers = flows.reduce((result, { name, onTrigger, onInstanceDeploy, onInstanceDelete }) => {
+        const key = flowFunctionKey(name, "onTrigger");
+        return Object.assign(Object.assign({}, result), { [key]: {
+                key,
+                display: {
+                    label: `${name} - onTrigger`,
+                    description: "The function that will be executed by the flow to return an HTTP response.",
+                },
+                perform: onTrigger,
+                onInstanceDeploy: onInstanceDeploy,
+                onInstanceDelete: onInstanceDelete,
+                inputs: [],
+                scheduleSupport: "valid",
+                synchronousResponseSupport: "valid",
+            } });
+    }, {});
+    const convertedDataSources = Object.entries(configVars).reduce((result, [key, configVar]) => {
+        if (!(0, types_1.isDataSourceConfigVar)(configVar)) {
+            return result;
+        }
+        const dataSource = (0, lodash_1.pick)(configVar, ["perform", "dataSourceType"]);
+        return Object.assign(Object.assign({}, result), { [key]: Object.assign(Object.assign({}, dataSource), { key: (0, lodash_1.camelCase)(key), display: {
+                    label: key,
+                    description: key,
+                }, inputs: [] }) });
+    }, {});
+    const convertedConnections = Object.entries(configVars).reduce((result, [key, configVar]) => {
+        if (!(0, types_1.isConnectionConfigVar)(configVar)) {
+            return result;
+        }
+        const convertedInputs = Object.entries(configVar.inputs).map(([key, value]) => (0, convert_1.convertInput)(key, value));
+        const connection = (0, lodash_1.pick)(configVar, ["oauth2Type", "iconPath"]);
+        return [
+            ...result,
+            Object.assign(Object.assign({}, connection), { inputs: convertedInputs, key: (0, lodash_1.camelCase)(key), label: key }),
+        ];
+    }, []);
+    return {
+        key: referenceKey,
+        display: {
+            label: referenceKey,
+            iconPath,
+            description: description || name,
+        },
+        connections: convertedConnections,
+        actions: convertedActions,
+        triggers: convertedTriggers,
+        dataSources: convertedDataSources,
+    };
+};

package/dist/serverTypes/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes } from "../types";
+import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes, ConfigVarResultCollection } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
@@ -48,13 +48,13 @@ export interface ActionLogger {
     warn: ActionLoggerFunction;
     error: ActionLoggerFunction;
 }
-export interface ActionContext {
+export declare type ActionContext<TConfigVars extends ConfigVarResultCollection> = {
     logger: ActionLogger;
-    configVars?: Record<string, unknown>;
     instanceState: Record<string, unknown>;
     crossFlowState: Record<string, unknown>;
     executionState: Record<string, unknown>;
     integrationState: Record<string, unknown>;
+    configVars: TConfigVars;
     stepId: string;
     executionId: string;
     webhookUrls: Record<string, string>;
@@ -66,7 +66,7 @@ export interface ActionContext {
     integration: IntegrationAttributes;
     flow: FlowAttributes;
     startedAt: string;
-}
+};
 declare type TriggerOptionChoice = "invalid" | "valid" | "required";
 export interface TriggerPayload {
     headers: Record<string, string>;
@@ -111,9 +111,9 @@ interface TriggerBranchingResult extends TriggerBaseResult {
     branch: string;
 }
 export declare type TriggerResult = TriggerBranchingResult | TriggerBaseResult | undefined;
-export declare type TriggerPerformFunction = (context: ActionContext, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
+export declare type TriggerPerformFunction = (context: ActionContext<any>, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
 export declare type TriggerEventFunctionResult = TriggerEventFunctionReturn | void;
-export declare type TriggerEventFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
+export declare type TriggerEventFunction = (context: ActionContext<any>, params: Record<string, unknown>) => Promise<TriggerEventFunctionResult>;
 export interface Trigger {
     key: string;
     display: DisplayDefinition & {
@@ -136,8 +136,9 @@ export interface Trigger {
     examplePayload?: unknown;
     isCommonTrigger?: boolean;
 }
-export interface DataSourceContext {
+export interface DataSourceContext<TConfigVars extends ConfigVarResultCollection> {
     logger: ActionLogger;
+    configVars: TConfigVars;
     customer: CustomerAttributes;
     instance: InstanceAttributes;
     user: UserAttributes;
@@ -149,7 +150,7 @@ export declare type DataSourceResult = {
         contentType: string;
     };
 };
-export declare type DataSourcePerformFunction = (context: DataSourceContext, params: Record<string, unknown>) => Promise<DataSourceResult>;
+export declare type DataSourcePerformFunction = (context: DataSourceContext<any>, params: Record<string, unknown>) => Promise<DataSourceResult>;
 export interface DataSource {
     key: string;
     display: DisplayDefinition & {
@@ -213,7 +214,7 @@ interface ServerPerformBranchingDataReturn extends ServerPerformDataReturn {
     branch: string;
 }
 export declare type ActionPerformReturn = ServerPerformDataStructureReturn | ServerPerformBranchingDataStructureReturn | ServerPerformDataReturn | ServerPerformBranchingDataReturn | undefined;
-export declare type ActionPerformFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
+export declare type ActionPerformFunction = (context: ActionContext<any>, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
 interface InputFieldChoice {
     label: string;
     value: string;

package/dist/serverTypes/integration.d.ts

@@ -0,0 +1,60 @@
+export declare const DefinitionVersion = 7;
+export interface ComponentReference {
+    key: string;
+    version: number | "LATEST";
+    isPublic: boolean;
+}
+export declare type Input = {
+    name?: string;
+    type: "value" | "reference" | "configVar" | "template";
+    value: string;
+    meta?: Record<string, unknown>;
+} | {
+    name?: string;
+    type: "complex";
+    value: string | Input;
+    meta?: Record<string, unknown>;
+};
+export interface ConnectionRequiredConfigVariable {
+    key: string;
+    stableKey: string;
+    description?: string;
+    orgOnly?: boolean;
+    dataType: "connection";
+    connection: {
+        component: ComponentReference;
+        key: string;
+    };
+    inputs?: Record<string, Input>;
+    meta?: Record<string, unknown>;
+}
+export interface DefaultRequiredConfigVariable {
+    key: string;
+    stableKey: string;
+    defaultValue?: string;
+    dataType: "string" | "date" | "timestamp" | "picklist" | "schedule" | "code" | "boolean" | "number" | "objectSelection" | "objectFieldMap" | "jsonForm";
+    pickList?: string[];
+    scheduleType?: "none" | "custom" | "minute" | "hour" | "day" | "week";
+    timeZone?: string;
+    codeLanguage?: "json" | "xml" | "html";
+    description?: string;
+    orgOnly?: boolean;
+    collectionType?: "valuelist" | "keyvaluelist";
+    dataSource?: {
+        component: ComponentReference;
+        key: string;
+    };
+    inputs?: Record<string, Input>;
+    meta?: Record<string, unknown>;
+}
+export declare type RequiredConfigVariable = DefaultRequiredConfigVariable | ConnectionRequiredConfigVariable;
+export interface ConfigPage {
+    name: string;
+    tagline?: string;
+    userLevelConfigured?: boolean;
+    elements: ConfigPageElement[];
+}
+export interface ConfigPageElement {
+    type: "configVar" | "htmlElement" | "jsonForm";
+    value: string;
+}

package/dist/serverTypes/integration.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefinitionVersion = void 0;
+exports.DefinitionVersion = 7;

package/dist/testing.d.ts

@@ -5,7 +5,7 @@
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
 import { TriggerPayload, TriggerResult, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn, DataSourceResult, DataSourceContext } from "./serverTypes";
-import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult, TriggerEventFunctionReturn, Flow } from "./types";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters, DataSourceDefinition, ActionPerformReturn as InvokeActionPerformReturn, TriggerResult as InvokeTriggerResult, DataSourceResult as InvokeDataSourceResult, TriggerEventFunctionReturn, Flow, ConfigVarResultCollection, ConfigPages } from "./types";
 export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>, tokenValues?: Record<string, unknown> | undefined) => ConnectionValue;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
@@ -25,7 +25,7 @@ interface InvokeReturn<ReturnData> {
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * action result and a mock logger for asserting logging.
  */
-export declare const invoke: <TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform }: ActionDefinition<TInputs, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn>>;
+export declare const 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>> | undefined) => Promise<InvokeReturn<TReturn>>;
 export declare const defaultTriggerPayload: () => TriggerPayload;
 /**
  * Invokes specified TriggerDefinition perform function using supplied params
@@ -33,13 +33,13 @@ export declare const defaultTriggerPayload: () => TriggerPayload;
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * trigger result and a mock logger for asserting logging.
  */
-export declare const invokeTrigger: <TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching>>({ perform }: TriggerDefinition<TInputs, TAllowsBranching, TResult>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs> | undefined) => Promise<InvokeReturn<TResult>>;
+export declare const 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>> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs> | undefined) => Promise<InvokeReturn<TResult>>;
 /**
  * Invokes specified DataSourceDefinition perform function using supplied params.
  * Accepts a generic type matching DataSourceResult as a convenience to avoid extra
  * casting within test methods. Returns a DataSourceResult.
  */
-export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType extends keyof {
+export declare const invokeDataSource: <TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TDataSourceType extends keyof {
     string: string;
     date: string;
     timestamp: string;
@@ -48,38 +48,40 @@ export declare const invokeDataSource: <TInputs extends Inputs, TDataSourceType
         value: string;
     };
     code: string;
-    credential: unknown;
     boolean: boolean;
     number: number;
-    connection: import("./types").Connection;
     objectSelection: import("./types").ObjectSelection;
     objectFieldMap: import("./types").ObjectFieldMap;
     jsonForm: import("./types").JSONForm;
-}>({ perform }: DataSourceDefinition<TInputs, TDataSourceType>, params: ActionInputParameters<TInputs>, context?: Partial<DataSourceContext> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
+}>({ perform }: DataSourceDefinition<TInputs, TConfigVars, TDataSourceType>, params: ActionInputParameters<TInputs>, context?: Partial<DataSourceContext<TConfigVars>> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
+declare type TestConnectionValue = Pick<ConnectionValue, "fields" | "context" | "token">;
+declare type TestConfigVarValues = Record<string, string | TestConnectionValue>;
+declare type ToTestValues<TConfigVars extends ConfigVarResultCollection> = {
+    [K in keyof TConfigVars]: TConfigVars[K] extends ConnectionDefinition ? TestConnectionValue : string;
+};
 /**
  * Invokes specified Flow of a Code Native Integration using supplied params.
  * Runs the Trigger and then the Action function and returns the result of the Action.
  */
-export declare const invokeFlow: (flow: Flow, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined) => Promise<InvokeReturn<InvokeActionPerformReturn<false, unknown>>>;
+export declare const invokeFlow: <TConfigPages extends ConfigPages, TConfigVars extends ConfigVarResultCollection = import("./types/utils").Prettify<{ [Key in keyof (TConfigPages extends ConfigPages ? import("./types/utils").UnionToIntersection<import("./types/utils").ValueOf<TConfigPages>["elements"]> : never)]: import("./types").ElementToRuntimeType<(TConfigPages extends ConfigPages ? import("./types/utils").UnionToIntersection<import("./types/utils").ValueOf<TConfigPages>["elements"]> : never)[Key]>; }>, TConfigVarValues extends TestConfigVarValues = ToTestValues<TConfigVars>>(flow: Flow<TConfigPages, import("./types").TriggerPayload>, configVars: TConfigVarValues, context?: Partial<ActionContext<TConfigVars>> | undefined, payload?: TriggerPayload | undefined) => Promise<InvokeReturn<InvokeActionPerformReturn<false, unknown>>>;
 export declare class ComponentTestHarness<TComponent extends Component> {
     component: TComponent;
     constructor(component: TComponent);
-    private buildContext;
     private buildParams;
     connectionValue({ key }: ConnectionDefinition): ConnectionValue;
-    trigger(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<TriggerResult>;
-    triggerOnInstanceDeploy(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<void | TriggerEventFunctionReturn>;
-    triggerOnInstanceDelete(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<void | TriggerEventFunctionReturn>;
-    action(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<ActionPerformReturn>;
-    dataSource(key: string, params?: Record<string, unknown>, context?: Partial<DataSourceContext>): Promise<DataSourceResult>;
+    trigger<TConfigVars extends ConfigVarResultCollection>(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<TriggerResult>;
+    triggerOnInstanceDeploy<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<void | TriggerEventFunctionReturn>;
+    triggerOnInstanceDelete<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<void | TriggerEventFunctionReturn>;
+    action<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext<TConfigVars>>): Promise<ActionPerformReturn>;
+    dataSource<TConfigVars extends ConfigVarResultCollection>(key: string, params?: Record<string, unknown>, context?: Partial<DataSourceContext<TConfigVars>>): Promise<DataSourceResult>;
 }
 export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 declare const _default: {
     loggerMock: () => ActionLogger;
-    invoke: <TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends InvokeActionPerformReturn<TAllowsBranching, unknown>>({ perform }: ActionDefinition<TInputs, TAllowsBranching, TReturn>, params: ActionInputParameters<TInputs>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<TReturn>>;
-    invokeTrigger: <TInputs_1 extends Inputs, TAllowsBranching_1 extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching_1>>({ perform }: TriggerDefinition<TInputs_1, TAllowsBranching_1, TResult>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs_1> | undefined) => Promise<InvokeReturn<TResult>>;
+    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>> | undefined) => Promise<InvokeReturn<TReturn>>;
+    invokeTrigger: <TInputs_1 extends Inputs, TConfigVars_1 extends ConfigVarResultCollection, TAllowsBranching_1 extends boolean, TResult extends InvokeTriggerResult<TAllowsBranching_1, TriggerPayload>>({ perform, }: TriggerDefinition<TInputs_1, TConfigVars_1, TAllowsBranching_1, TResult>, context?: Partial<ActionContext<TConfigVars_1>> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<TInputs_1> | undefined) => Promise<InvokeReturn<TResult>>;
     createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
-    invokeDataSource: <TInputs_2 extends Inputs, TDataSourceType extends keyof {
+    invokeDataSource: <TInputs_2 extends Inputs, TConfigVars_2 extends ConfigVarResultCollection, TDataSourceType extends keyof {
         string: string;
         date: string;
         timestamp: string;
@@ -88,13 +90,11 @@ declare const _default: {
             value: string;
         };
         code: string;
-        credential: unknown;
         boolean: boolean;
         number: number;
-        connection: import("./types").Connection;
         objectSelection: import("./types").ObjectSelection;
         objectFieldMap: import("./types").ObjectFieldMap;
         jsonForm: import("./types").JSONForm;
-    }>({ perform }: DataSourceDefinition<TInputs_2, TDataSourceType>, params: ActionInputParameters<TInputs_2>, context?: Partial<DataSourceContext> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
+    }>({ perform }: DataSourceDefinition<TInputs_2, TConfigVars_2, TDataSourceType>, params: ActionInputParameters<TInputs_2>, context?: Partial<DataSourceContext<TConfigVars_2>> | undefined) => Promise<InvokeDataSourceResult<TDataSourceType>>;
 };
 export default _default;