@prismatic-io/spectral 8.0.0-preview8 → 8.0.1

package/dist/testing.js

@@ -38,47 +38,47 @@ const loggerMock = () => ({
     error: (0, jest_mock_1.spyOn)(console, "error"),
 });
 exports.loggerMock = loggerMock;
-const baseActionContext = {
-    logger: (0, exports.loggerMock)(),
-    instanceState: {},
-    crossFlowState: {},
-    executionState: {},
-    integrationState: {},
-    stepId: "mockStepId",
-    executionId: "mockExecutionId",
-    webhookUrls: {
-        "Flow 1": "https://example.com",
-    },
-    webhookApiKeys: {
-        "Flow 1": ["example-123", "example-456"],
-    },
-    invokeUrl: "https://example.com",
-    customer: {
-        id: "customerId",
-        name: "Customer 1",
-        externalId: "1234",
-    },
-    instance: {
-        id: "instanceId",
-        name: "Instance 1",
-    },
-    user: {
-        id: "userId",
-        email: "user@example.com",
-        name: "User 1",
-        externalId: "1234",
-    },
-    integration: {
-        id: "integrationId",
-        name: "Integration 1",
-        versionSequenceId: "1234",
-        externalVersion: "1.0.0",
-    },
-    flow: {
-        id: "flowId",
-        name: "Flow 1",
-    },
-    startedAt: new Date().toISOString(),
+const createActionContext = (context) => {
+    return Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, integrationState: {}, configVars: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
+            "Flow 1": "https://example.com",
+        }, webhookApiKeys: {
+            "Flow 1": ["example-123", "example-456"],
+        }, invokeUrl: "https://example.com", customer: {
+            id: "customerId",
+            name: "Customer 1",
+            externalId: "1234",
+        }, instance: {
+            id: "instanceId",
+            name: "Instance 1",
+        }, user: {
+            id: "userId",
+            email: "user@example.com",
+            name: "User 1",
+            externalId: "1234",
+        }, integration: {
+            id: "integrationId",
+            name: "Integration 1",
+            versionSequenceId: "1234",
+            externalVersion: "1.0.0",
+        }, flow: {
+            id: "flowId",
+            name: "Flow 1",
+        }, startedAt: new Date().toISOString() }, context);
+};
+const createDataSourceContext = (context) => {
+    return Object.assign({ logger: (0, exports.loggerMock)(), configVars: {}, customer: {
+            id: "customerId",
+            name: "Customer 1",
+            externalId: "1234",
+        }, instance: {
+            id: "instanceId",
+            name: "Instance 1",
+        }, user: {
+            id: "userId",
+            email: "example@email.com",
+            externalId: "1234",
+            name: "Example",
+        } }, context);
 };
 /**
  * Invokes specified ActionDefinition perform function using supplied params
@@ -86,8 +86,8 @@ const baseActionContext = {
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * action result and a mock logger for asserting logging.
  */
-const invoke = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
+const invoke = ({ perform, }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = createActionContext(context);
     const result = yield perform(realizedContext, params);
     return {
         result,
@@ -155,8 +155,8 @@ exports.defaultTriggerPayload = defaultTriggerPayload;
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * trigger result and a mock logger for asserting logging.
  */
-const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
+const invokeTrigger = ({ perform, }, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = createActionContext(context);
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const realizedParams = params || {};
     const result = yield perform(realizedContext, realizedPayload, realizedParams);
@@ -166,46 +166,40 @@ const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void
     };
 });
 exports.invokeTrigger = invokeTrigger;
-const baseDataSourceContext = {
-    logger: (0, exports.loggerMock)(),
-    customer: {
-        id: "customerId",
-        name: "Customer 1",
-        externalId: "1234",
-    },
-    instance: {
-        id: "instanceId",
-        name: "Instance 1",
-    },
-    user: {
-        id: "userId",
-        email: "example@email.com",
-        externalId: "1234",
-        name: "Example",
-    },
-};
 /**
  * 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.
  */
 const invokeDataSource = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign(Object.assign({}, baseDataSourceContext), context);
+    const realizedContext = createDataSourceContext(context);
     const result = yield perform(realizedContext, params);
     return result;
 });
 exports.invokeDataSource = invokeDataSource;
+const createConfigVars = (values) => {
+    return Object.entries(values).reduce((result, [key, value]) => {
+        // Connection
+        if (typeof value === "object" && "fields" in value) {
+            return Object.assign(Object.assign({}, result), { [key]: Object.assign(Object.assign({}, value), { key, configVarKey: "" }) });
+        }
+        return Object.assign(Object.assign({}, result), { [key]: value });
+    }, {});
+};
 /**
  * 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.
  */
-const invokeFlow = (flow, context, payload) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
+const invokeFlow = (flow, configVars, context, payload) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedConfigVars = createConfigVars(configVars);
+    const realizedContext = createActionContext(Object.assign(Object.assign({}, context), { configVars: realizedConfigVars }));
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
-    const params = {};
+    const params = {
+        onTrigger: { results: null },
+    };
     if ("onTrigger" in flow) {
         const triggerResult = yield flow.onTrigger(realizedContext, realizedPayload, params);
-        params.trigger = triggerResult;
+        params.onTrigger = { results: triggerResult === null || triggerResult === void 0 ? void 0 : triggerResult.payload };
     }
     const result = yield flow.onExecution(realizedContext, params);
     return {
@@ -218,9 +212,6 @@ class ComponentTestHarness {
     constructor(component) {
         this.component = component;
     }
-    buildContext(baseContext, context) {
-        return Object.assign(Object.assign({}, baseContext), context);
-    }
     buildParams(inputs, params) {
         const defaults = inputs.reduce((result, { key, default: defaultValue }) => (Object.assign(Object.assign({}, result), { [key]: `${defaultValue !== null && defaultValue !== void 0 ? defaultValue : ""}` })), {});
         return Object.assign(Object.assign({}, defaults), params);
@@ -236,7 +227,7 @@ class ComponentTestHarness {
     trigger(key, payload, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const trigger = this.component.triggers[key];
-            return trigger.perform(this.buildContext(baseActionContext, context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
+            return trigger.perform(createActionContext(context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
         });
     }
     triggerOnInstanceDeploy(key, params, context) {
@@ -245,7 +236,7 @@ class ComponentTestHarness {
             if (!trigger.onInstanceDeploy) {
                 throw new Error("Trigger does not support onInstanceDeploy");
             }
-            return trigger.onInstanceDeploy(this.buildContext(baseActionContext, context), this.buildParams(trigger.inputs, params));
+            return trigger.onInstanceDeploy(createActionContext(context), this.buildParams(trigger.inputs, params));
         });
     }
     triggerOnInstanceDelete(key, params, context) {
@@ -254,19 +245,19 @@ class ComponentTestHarness {
             if (!trigger.onInstanceDelete) {
                 throw new Error("Trigger does not support onInstanceDelete");
             }
-            return trigger.onInstanceDelete(this.buildContext(baseActionContext, context), this.buildParams(trigger.inputs, params));
+            return trigger.onInstanceDelete(createActionContext(context), this.buildParams(trigger.inputs, params));
         });
     }
     action(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const action = this.component.actions[key];
-            return action.perform(this.buildContext(baseActionContext, context), this.buildParams(action.inputs, params));
+            return action.perform(createActionContext(context), this.buildParams(action.inputs, params));
         });
     }
     dataSource(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const dataSource = this.component.dataSources[key];
-            return dataSource.perform(this.buildContext(baseDataSourceContext, context), this.buildParams(dataSource.inputs, params));
+            return dataSource.perform(createDataSourceContext(context), this.buildParams(dataSource.inputs, params));
         });
     }
 }

package/dist/types/ActionDefinition.d.ts

@@ -1,13 +1,13 @@
-import { ActionDisplayDefinition, ActionPerformFunction, ActionPerformReturn, Inputs } from ".";
+import { ActionDisplayDefinition, ActionPerformFunction, ActionPerformReturn, ConfigVarResultCollection, Inputs } from ".";
 /**
  * ActionDefinition is the type of the object that is passed in to `action` function to
  * define a component action.
  */
-export interface ActionDefinition<TInputs extends Inputs, TAllowsBranching extends boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> {
+export interface ActionDefinition<TInputs extends Inputs = Inputs, TConfigVars extends ConfigVarResultCollection = ConfigVarResultCollection, TAllowsBranching extends boolean = boolean, TReturn extends ActionPerformReturn<TAllowsBranching, unknown> = ActionPerformReturn<TAllowsBranching, unknown>> {
     /** Defines how the Action is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Action is invoked. */
-    perform: ActionPerformFunction<TInputs, TAllowsBranching, TReturn>;
+    perform: ActionPerformFunction<TInputs, TConfigVars, TAllowsBranching, TReturn>;
     /** InputFields to present in the Prismatic interface for configuration of this Action. */
     inputs: TInputs;
     /** Optional attribute that specifies whether an Action will terminate execution.*/

package/dist/types/ActionInputParameters.d.ts

@@ -1,6 +1,6 @@
 import { Inputs } from ".";
 import { ConditionalExpression } from "./conditional-logic";
-import { InputFieldCollection, InputCleanFunction, Connection } from "./Inputs";
+import { InputFieldCollection, InputCleanFunction, Connection, KeyValuePair } from "./Inputs";
 /**
  * Collection of input parameters.
  * Inputs can be static values, references to config variables, or
@@ -10,16 +10,3 @@ export declare type ActionInputParameters<TInputs extends Inputs> = {
     [Property in keyof TInputs]: TInputs[Property]["clean"] extends InputCleanFunction<any> ? ReturnType<TInputs[Property]["clean"]> : TInputs[Property]["type"] extends "connection" ? ExtractValue<Connection, TInputs[Property]["collection"]> : TInputs[Property]["type"] extends "conditional" ? ExtractValue<ConditionalExpression, TInputs[Property]["collection"]> : ExtractValue<TInputs[Property]["default"], TInputs[Property]["collection"]>;
 };
 export declare type ExtractValue<TType, TCollection extends InputFieldCollection | undefined> = TCollection extends "keyvaluelist" ? KeyValuePair<TType>[] : TCollection extends "valuelist" ? TType[] : TType;
-/**
- * KeyValuePair input parameter type.
- * This allows users to input multiple keys / values as an input.
- * To see an example of how this can be used, see the `tagging` input
- * of the `putObject` action of the AWS S3 component:
- * https://github.com/prismatic-io/examples/blob/main/components/aws-s3/src/actions.ts
- */
-export interface KeyValuePair<V = unknown> {
-    /** Key of the KeyValuePair */
-    key: string;
-    /** Value of the KeyValuePair */
-    value: V;
-}

package/dist/types/ActionPerformFunction.d.ts

@@ -1,12 +1,10 @@
-import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger, InstanceAttributes, CustomerAttributes, UserAttributes, IntegrationAttributes, FlowAttributes } from ".";
+import { Inputs, ConfigVarResultCollection, ActionPerformReturn, ActionInputParameters, ActionLogger, InstanceAttributes, CustomerAttributes, UserAttributes, IntegrationAttributes, FlowAttributes } from ".";
 /** Definition of the function to perform when an Action is invoked. */
-export declare type ActionPerformFunction<TInputs extends Inputs, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
+export declare type ActionPerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext<TConfigVars>, params: ActionInputParameters<TInputs>) => Promise<TReturn>;
 /** Context provided to perform method containing helpers and contextual data */
-export interface ActionContext {
+export declare type ActionContext<TConfigVars extends ConfigVarResultCollection> = {
     /** Logger for permanent logging; console calls are also captured */
     logger: ActionLogger;
-    /** Code Components and Code Native Integration Actions will have access to all Config Vars, otherwise this will be undefined. */
-    configVars?: Record<string, unknown>;
     /** A a flow-specific key/value store that may be used to store small amounts of data that is persisted between Instance executions */
     instanceState: Record<string, unknown>;
     /** A key/value store that is shared between flows on an Instance that may be used to store small amounts of data that is persisted between Instance executions */
@@ -15,6 +13,8 @@ export interface ActionContext {
     executionState: Record<string, unknown>;
     /** A key/value store that is shared between all flows of an Instance for any version of an Integration that may be used to store small amounts of data that is persisted between Instance executions */
     integrationState: Record<string, unknown>;
+    /** Key/value collection of config variables of the integration. */
+    configVars: TConfigVars;
     /** A unique id that corresponds to the step on the Integration */
     stepId: string;
     /** A unique id that corresponds to the specific execution of the Integration */
@@ -37,4 +37,4 @@ export interface ActionContext {
     flow: FlowAttributes;
     /** The time in UTC that execution started. */
     startedAt: string;
-}
+};

package/dist/types/ComponentDefinition.d.ts

@@ -13,11 +13,11 @@ export declare type ComponentDefinition<TPublic extends boolean, TKey extends st
     /** Defines how the Component is displayed in the Prismatic interface. */
     display: ComponentDisplayDefinition<TPublic>;
     /** Specifies the supported Actions of this Component. */
-    actions?: Record<string, ActionDefinition<any, boolean, any>>;
+    actions?: Record<string, ActionDefinition<any, any, boolean, any>>;
     /** Specifies the supported Triggers of this Component. */
-    triggers?: Record<string, TriggerDefinition<any, boolean, any>>;
+    triggers?: Record<string, TriggerDefinition<any, any, boolean, any>>;
     /** Specifies the supported Data Sources of this Component. */
-    dataSources?: Record<string, DataSourceDefinition<any, any>>;
+    dataSources?: Record<string, DataSourceDefinition<any, any, any>>;
     /** Specifies the supported Connections of this Component. */
     connections?: ConnectionDefinition[];
     /** Hooks */

package/dist/types/DataSourceDefinition.d.ts

@@ -1,13 +1,13 @@
-import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceType } from ".";
+import { ActionDisplayDefinition, DataSourcePerformFunction, Inputs, DataSourceType, ConfigVarResultCollection } from ".";
 /**
  * DataSourceDefinition is the type of the object that is passed in to `dataSource` function to
  * define a component Data Source.
  */
-export interface DataSourceDefinition<TInputs extends Inputs, TDataSourceType extends DataSourceType> {
+export interface DataSourceDefinition<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TDataSourceType extends DataSourceType> {
     /** Defines how the Data Source is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Data Source is invoked; fetches data from the data source. */
-    perform: DataSourcePerformFunction<TInputs, TDataSourceType>;
+    perform: DataSourcePerformFunction<TInputs, TConfigVars, TDataSourceType>;
     /** The type of data that this Data Source represents. */
     dataSourceType: TDataSourceType;
     /** InputFields to present in the Prismatic interface for configuration of this Data Source. */

package/dist/types/DataSourcePerformFunction.d.ts

@@ -1,10 +1,5 @@
-import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters, ActionLogger, CustomerAttributes, InstanceAttributes, UserAttributes } from ".";
+import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters, ConfigVarResultCollection, ActionContext } from ".";
 /** Context provided to perform method containing helpers and contextual data */
-export interface DataSourceContext {
-    logger: ActionLogger;
-    customer: CustomerAttributes;
-    instance: InstanceAttributes;
-    user: UserAttributes;
-}
+export declare type DataSourceContext<TConfigVars extends ConfigVarResultCollection> = Pick<ActionContext<TConfigVars>, "logger" | "customer" | "instance" | "user" | "configVars">;
 /** Definition of the function to perform when a Data Source is invoked. */
-export declare type DataSourcePerformFunction<TInputs extends Inputs, TDataSourceType extends DataSourceType> = (context: DataSourceContext, params: ActionInputParameters<TInputs>) => Promise<DataSourceResult<TDataSourceType>>;
+export declare type DataSourcePerformFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TDataSourceType extends DataSourceType> = (context: DataSourceContext<TConfigVars>, params: ActionInputParameters<TInputs>) => Promise<DataSourceResult<TDataSourceType>>;

package/dist/types/DataSourceResult.d.ts

@@ -1,4 +1,4 @@
-import { ObjectSelection, ObjectFieldMap, JSONForm, Element, Connection } from "./Inputs";
+import { ObjectSelection, ObjectFieldMap, JSONForm, Element } from "./Inputs";
 /** The type of field that is appropriate for rendering the data that is the result of the data source perform function. */
 declare type DataSourceTypeMap = {
     string: string;
@@ -9,10 +9,8 @@ declare type DataSourceTypeMap = {
         value: string;
     };
     code: string;
-    credential: unknown;
     boolean: boolean;
     number: number;
-    connection: Connection;
     objectSelection: ObjectSelection;
     objectFieldMap: ObjectFieldMap;
     jsonForm: JSONForm;

package/dist/types/Inputs.d.ts

@@ -1,5 +1,18 @@
 import { ConditionalExpression } from "./conditional-logic";
 import { JsonSchema, UISchemaElement } from "@jsonforms/core";
+/**
+ * KeyValuePair input parameter type.
+ * This allows users to input multiple keys / values as an input.
+ * To see an example of how this can be used, see the `tagging` input
+ * of the `putObject` action of the AWS S3 component:
+ * https://github.com/prismatic-io/examples/blob/main/components/aws-s3/src/actions.ts
+ */
+export interface KeyValuePair<V = unknown> {
+    /** Key of the KeyValuePair */
+    key: string;
+    /** Value of the KeyValuePair */
+    value: V;
+}
 export declare type Element = {
     key: string;
     label?: string;
@@ -66,81 +79,76 @@ interface BaseInputField {
     /** Indicate if this InputField is required. */
     required?: boolean;
 }
-export interface StringInputField extends BaseInputField {
-    /** Data type the InputField will collect. */
-    type: "string";
+declare type CollectionOptions<T> = SingleValue<T> | ValueListCollection<T> | KeyValueListCollection<T>;
+interface SingleValue<T> {
     /** Collection type of the InputField */
-    collection?: InputFieldCollection;
+    collection?: undefined;
     /** Default value for this field. */
-    default?: unknown;
+    default?: T;
+}
+interface ValueListCollection<T> {
+    /** Collection type of the InputField */
+    collection: "valuelist";
+    /** Default value for this field. */
+    default?: T[];
+}
+interface KeyValueListCollection<T> {
+    /** Collection type of the InputField */
+    collection: "keyvaluelist";
+    /** Default value for this field. */
+    default?: KeyValuePair<T>[];
+}
+export declare type StringInputField = BaseInputField & CollectionOptions<string> & {
+    /** Data type the InputField will collect. */
+    type: "string";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface DataInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type DataInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "data";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface TextInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type TextInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "text";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface PasswordInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type PasswordInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "password";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface BooleanInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type BooleanInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "boolean";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
+    clean?: InputCleanFunction<unknown>;
+};
 /** Defines attributes of a CodeInputField. */
-export interface CodeInputField extends BaseInputField {
+export declare type CodeInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "code";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Code language for syntax highlighting. For no syntax highlighting, choose "plaintext" */
     language: "css" | "graphql" | "handlebars" | "hcl" | "html" | "javascript" | "json" | "liquid" | "markdown" | "mysql" | "pgsql" | "plaintext" | "sql" | "typescript" | "xml" | "yaml";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
+    clean?: InputCleanFunction<unknown>;
+};
 /** Defines attributes of a ConditionalInputField. */
 export interface ConditionalInputField extends BaseInputField {
     /** Data type the InputField will collect. */
@@ -239,4 +247,6 @@ export interface InputFieldChoice {
 }
 /** InputField collection enumeration */
 export declare type InputFieldCollection = "valuelist" | "keyvaluelist";
+/** Config variable result collection */
+export declare type ConfigVarResultCollection = Record<string, string | Connection | JSONForm | ObjectSelection | ObjectFieldMap>;
 export {};