@prismatic-io/spectral 9.0.0-rc.8 → 9.0.0

package/dist/serverTypes/convertIntegration.js

@@ -28,7 +28,7 @@ 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 convertComponent_1 = require("./convertComponent");
 const integration_1 = require("./integration");
 const convertIntegration = (definition) => {
     var _a, _b;
@@ -162,6 +162,9 @@ const convertConfigVarPermissionAndVisibility = ({ permissionAndVisibilityType,
 const convertComponentReference = (componentReference, componentRegistry) => {
     var _a, _b;
     const manifest = componentRegistry[componentReference.component];
+    if (!manifest) {
+        throw new Error(`Component with key "${componentReference.component}" not found in component registry.`);
+    }
     const ref = {
         component: {
             key: manifest.key,
@@ -282,6 +285,19 @@ const convertFlow = (flow, componentRegistry, referenceKey) => {
     result.supplementalComponents = convertComponentRegistry(componentRegistry);
     return result;
 };
+/** Converts an input value to the expected server type by its collection type */
+const convertInputValue = (value, collectionType) => {
+    if (collectionType !== "keyvaluelist") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value;
+    }
+    return Object.entries(value).map(([key, value]) => ({
+        key,
+        value,
+    }));
+};
 /** Converts a Config Var into the structure necessary for YAML generation. */
 const convertConfigVar = (key, configVar, referenceKey, componentRegistry) => {
     const { orgOnly, meta } = convertConfigVarPermissionAndVisibility((0, lodash_1.pick)(configVar, ["permissionAndVisibilityType", "visibleToOrgDeployer"]));
@@ -315,22 +331,30 @@ const convertConfigVar = (key, configVar, referenceKey, componentRegistry) => {
     }
     if ((0, types_1.isConnectionReferenceConfigVar)(configVar)) {
         const { ref, inputs } = convertComponentReference(configVar.connection, componentRegistry);
-        const { stableKey = "", description, connection: { template }, } = (0, lodash_1.pick)(configVar, ["stableKey", "description", "connection"]);
+        const { stableKey = "", description, connection: { template, onPremiseConnectionConfig }, } = (0, lodash_1.pick)(configVar, ["stableKey", "description", "connection"]);
         return {
             stableKey,
             description,
             key,
             dataType: "connection",
-            connection: Object.assign(Object.assign({}, ref), { template }),
+            connection: Object.assign(Object.assign({}, ref), { template,
+                onPremiseConnectionConfig }),
             inputs,
             orgOnly,
             meta,
         };
     }
-    const result = (0, lodash_1.assign)({ orgOnly, meta, key }, (0, lodash_1.pick)(configVar, [
+    const rawDefaultValue = "defaultValue" in configVar
+        ? convertInputValue(configVar.defaultValue, configVar.collectionType)
+        : undefined;
+    const defaultValue = typeof rawDefaultValue !== "undefined"
+        ? typeof rawDefaultValue === "string"
+            ? rawDefaultValue
+            : JSON.stringify(rawDefaultValue)
+        : undefined;
+    const result = (0, lodash_1.assign)({ orgOnly, meta, key, defaultValue }, (0, lodash_1.pick)(configVar, [
         "stableKey",
         "description",
-        "defaultValue",
         "dataType",
         "pickList",
         "timeZone",
@@ -349,7 +373,8 @@ const convertConfigVar = (key, configVar, referenceKey, componentRegistry) => {
     }
     if ((0, types_1.isDataSourceReferenceConfigVar)(configVar)) {
         const { ref, inputs } = convertComponentReference(configVar.dataSource, componentRegistry);
-        result.dataType = configVar.dataSourceType;
+        result.dataType =
+            componentRegistry[ref.component.key]["dataSources"][ref.key]["dataSourceType"];
         result.dataSource = ref;
         result.inputs = inputs;
     }
@@ -374,32 +399,20 @@ const flowFunctionKey = (flowName, functionName) => {
     return `${flowKey}_${functionName}`;
 };
 const convertOnExecution = (onExecution, componentRegistry) => (context, params) => {
+    const { 
     // @ts-expect-error _components isn't part of the public API
-    const { _components } = context, remainingContext = __rest(context, ["_components"]);
+    _components } = context, remainingContext = __rest(context, ["_components"]);
     const invoke = _components
         .invoke;
     // Construct the component methods from the component registry
     const componentMethods = Object.entries(componentRegistry).reduce((accumulator, [registryComponentKey, { key: componentKey, actions, public: isPublic, signature },]) => {
-        // Create an object to hold the methods for each action
-        const methods = Object.keys(actions).reduce((methodsAccumulator, actionKey) => {
-            const action = actions[actionKey];
+        const componentActions = Object.entries(actions).reduce((actionsAccumulator, [actionKey, action]) => {
             // Define the method to be called for the action
-            methodsAccumulator[actionKey] = (values) => __awaiter(void 0, void 0, void 0, function* () {
+            const invokeAction = (values) => __awaiter(void 0, void 0, void 0, function* () {
                 // Transform the input values based on the action's inputs
                 const transformedValues = Object.entries(values).reduce((transformedAccumulator, [inputKey, inputValue]) => {
                     const { collection } = action.inputs[inputKey];
-                    // Transform key-value list inputs
-                    if (collection === "keyvaluelist" &&
-                        Object.keys(inputValue).length) {
-                        transformedAccumulator[inputKey] = Object.entries(inputValue).map(([keyItem, valueItem]) => ({
-                            key: keyItem,
-                            value: valueItem,
-                        }));
-                    }
-                    else {
-                        transformedAccumulator[inputKey] = inputValue;
-                    }
-                    return transformedAccumulator;
+                    return Object.assign(Object.assign({}, transformedAccumulator), { [inputKey]: convertInputValue(inputValue, collection) });
                 }, {});
                 // Invoke the action with the transformed values
                 return invoke({
@@ -411,11 +424,9 @@ const convertOnExecution = (onExecution, componentRegistry) => (context, params)
                     key: actionKey,
                 }, context, transformedValues);
             });
-            return methodsAccumulator;
+            return Object.assign(Object.assign({}, actionsAccumulator), { [actionKey]: invokeAction });
         }, {});
-        // Add the methods to the accumulator under the registry component key
-        accumulator[registryComponentKey] = methods;
-        return accumulator;
+        return Object.assign(Object.assign({}, accumulator), { [registryComponentKey]: componentActions });
     }, {});
     return onExecution(Object.assign(Object.assign({}, remainingContext), { components: componentMethods }), params);
 };
@@ -470,7 +481,7 @@ const codeNativeIntegrationComponent = ({ name, iconPath, description, flows = [
         if (!(0, types_1.isConnectionDefinitionConfigVar)(configVar)) {
             return result;
         }
-        const convertedInputs = Object.entries(configVar.inputs).map(([key, value]) => (0, convert_1.convertInput)(key, value));
+        const convertedInputs = Object.entries(configVar.inputs).map(([key, value]) => (0, convertComponent_1.convertInput)(key, value));
         const connection = (0, lodash_1.pick)(configVar, ["oauth2Type", "iconPath"]);
         return [
             ...result,

package/dist/serverTypes/integration.d.ts

@@ -7,6 +7,7 @@ export declare type ComponentReference = {
     };
     key: string;
     template?: string;
+    onPremiseConnectionConfig?: string;
 } | {
     component: {
         key: string;
@@ -15,6 +16,7 @@ export declare type ComponentReference = {
     };
     key: string;
     template?: string;
+    onPremiseConnectionConfig?: string;
 };
 export declare type Input = {
     name?: string | Input;

package/dist/types/ComponentManifest.d.ts

@@ -1,3 +1,4 @@
+import { CollectionType, DataSourceType, InputFieldType } from ".";
 export interface ComponentManifest {
     key: string;
     public: boolean;
@@ -7,31 +8,30 @@ export interface ComponentManifest {
     dataSources: Record<string, ComponentManifestDataSource>;
     connections: Record<string, ComponentManifestConnection>;
 }
+interface BaseInput {
+    inputType: InputFieldType;
+    collection?: CollectionType | undefined;
+    required?: boolean;
+    default?: unknown;
+}
 export interface ComponentManifestAction {
     perform: (values: any) => Promise<unknown>;
-    inputs: Record<string, {
-        inputType: string;
-        collection: "keyvaluelist" | "valuelist" | null;
-    }>;
+    inputs: Record<string, BaseInput>;
 }
 export interface ComponentManifestTrigger {
     perform: (values: any) => Promise<unknown>;
-    inputs: Record<string, {
-        inputType: string;
-        collection: "keyvaluelist" | "valuelist" | null;
-    }>;
+    inputs: Record<string, BaseInput>;
 }
 export interface ComponentManifestDataSource {
     perform: (values: any) => Promise<unknown>;
-    inputs: Record<string, {
-        inputType: string;
-        collection: "keyvaluelist" | "valuelist" | null;
-    }>;
+    dataSourceType: DataSourceType;
+    inputs: Record<string, BaseInput>;
 }
 export interface ComponentManifestConnection {
     perform: (values: any) => Promise<unknown>;
-    inputs: Record<string, {
-        inputType: string;
-        collection: "keyvaluelist" | "valuelist" | null;
+    onPremAvailable?: boolean;
+    inputs: Record<string, BaseInput & {
+        onPremControlled?: boolean;
     }>;
 }
+export {};

package/dist/types/ComponentRegistry.d.ts

@@ -0,0 +1,89 @@
+import { ComponentManifest, PermissionAndVisibilityType } from ".";
+import { Prettify, UnionToIntersection } from "./utils";
+/**
+ * Root ComponentRegistry type exposed for augmentation.
+ *
+ * The expected interface when augmenting is:
+ *
+ * ```ts
+ * interface IntegrationDefinitionComponentRegistry {
+ *   [key: string]: ComponentManifest
+ * }
+ * ```
+ *
+ */
+export interface IntegrationDefinitionComponentRegistry {
+}
+export declare type ComponentRegistry = keyof IntegrationDefinitionComponentRegistry extends never ? {
+    [key: string]: ComponentManifest;
+} : UnionToIntersection<keyof IntegrationDefinitionComponentRegistry extends infer TComponentKey ? TComponentKey extends keyof IntegrationDefinitionComponentRegistry ? {
+    [Key in TComponentKey]: IntegrationDefinitionComponentRegistry[TComponentKey];
+} : never : never>;
+export interface ConnectionInputPermissionAndVisibility {
+    /**
+     * Optional value that sets the permission and visibility of the Config Var. @default "customer"
+     *
+     * "customer" - Customers can view and edit the Config Var.
+     * "embedded" - Customers cannot view or update the Config Var as the value will be set programmatically.
+     * "organization" - Customers cannot view or update the Config Var as it will always have a default value or be set by the organization.
+     */
+    permissionAndVisibilityType?: PermissionAndVisibilityType;
+    /** Optional value that specifies whether this Config Var is visible to an Organization deployer. @default true */
+    visibleToOrgDeployer?: boolean;
+}
+export declare type ConfigVarExpression = {
+    configVar: string;
+};
+export declare type ValueExpression<TValueType = unknown> = {
+    value: TValueType;
+};
+declare type ComponentReferenceType = Extract<keyof ComponentManifest, "actions" | "triggers" | "dataSources" | "connections">;
+declare type ComponentReferenceTypeValueMap<TValue, TMap extends Record<ComponentReferenceType, unknown> = {
+    actions: ValueExpression<TValue>;
+    triggers: ValueExpression<TValue> | ConfigVarExpression;
+    dataSources: ValueExpression<TValue> | ConfigVarExpression;
+    connections: (ValueExpression<TValue> | ConfigVarExpression) & ConnectionInputPermissionAndVisibility;
+}> = TMap;
+export declare type ComponentReference<TComponentReference extends {
+    component: string;
+    key: string;
+    values?: {
+        [key: string]: ValueExpression | ConfigVarExpression;
+    };
+    template?: string;
+} = {
+    component: string;
+    key: string;
+    values?: {
+        [key: string]: ValueExpression | ConfigVarExpression;
+    };
+    template?: string;
+}> = TComponentReference;
+export declare const isComponentReference: (ref: unknown) => ref is {
+    component: string;
+    key: string;
+    values?: {
+        [key: string]: ConfigVarExpression | ValueExpression<unknown>;
+    } | undefined;
+    template?: string | undefined;
+};
+declare type ComponentRegistryFunctionsByType = UnionToIntersection<ComponentReferenceType extends infer TComponentReferenceType ? TComponentReferenceType extends Extract<keyof ComponentManifest, "actions" | "triggers" | "dataSources" | "connections"> ? {
+    [Key in TComponentReferenceType]: keyof ComponentRegistry extends infer TComponentKey ? TComponentKey extends keyof ComponentRegistry ? TComponentKey extends string ? TComponentReferenceType extends keyof ComponentRegistry[TComponentKey] ? keyof ComponentRegistry[TComponentKey][TComponentReferenceType] extends infer TComponentPropertyKey ? TComponentPropertyKey extends keyof ComponentRegistry[TComponentKey][TComponentReferenceType] ? TComponentPropertyKey extends string ? "perform" extends keyof ComponentRegistry[TComponentKey][TComponentReferenceType][TComponentPropertyKey] ? ComponentRegistry[TComponentKey][TComponentReferenceType][TComponentPropertyKey]["perform"] extends (...args: any[]) => any ? Parameters<ComponentRegistry[TComponentKey][TComponentReferenceType][TComponentPropertyKey]["perform"]>[0] extends infer TInputs ? Prettify<Omit<ComponentRegistry[TComponentKey][TComponentReferenceType][TComponentPropertyKey], "perform"> & {
+        reference: ComponentReference<{
+            component: TComponentKey;
+            key: TComponentPropertyKey;
+            values: {
+                [Key in keyof TInputs]: ComponentReferenceTypeValueMap<TInputs[Key]>[TComponentReferenceType];
+            };
+        }>;
+    }> : never : never : never : never : never : never : never : never : never : never;
+} : never : never>;
+export declare type ComponentRegistryTrigger = ComponentRegistryFunctionsByType["triggers"];
+export declare type TriggerReference = ComponentRegistryTrigger["reference"];
+export declare type ComponentRegistryAction = ComponentRegistryFunctionsByType["actions"];
+export declare type ActionReference = ComponentRegistryAction["reference"];
+export declare type ComponentRegistryDataSource = ComponentRegistryFunctionsByType["dataSources"];
+export declare type DataSourceReference = ComponentRegistryDataSource["reference"];
+export declare type ComponentRegistryConnection = ComponentRegistryFunctionsByType["connections"];
+export declare type ConnectionReference = ComponentRegistryConnection["reference"];
+export {};

package/dist/types/ComponentRegistry.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isComponentReference = void 0;
+const isComponentReference = (ref) => typeof ref === "object" && ref !== null && "key" in ref && "component" in ref;
+exports.isComponentReference = isComponentReference;

package/dist/types/ConfigPages.d.ts

@@ -0,0 +1,46 @@
+import { ConfigVar } from ".";
+import { UnionToIntersection } from "./utils";
+/**
+ * Root ConfigPages type exposed for augmentation.
+ *
+ * The expected interface when augmenting is:
+ *
+ * ```ts
+ * interface IntegrationDefinitionConfigPages {
+ *   [key: string]: ConfigPage
+ * }
+ * ```
+ *
+ */
+export interface IntegrationDefinitionConfigPages {
+}
+/**
+ * Root UserLevelConfigPages type exposed for augmentation.
+ *
+ * The expected interface when augmenting is:
+ *
+ * ```ts
+ * interface IntegrationDefinitionUserLevelConfigPages {
+ *   [key: string]: ConfigPage
+ * }
+ * ```
+ *
+ */
+export interface IntegrationDefinitionUserLevelConfigPages {
+}
+export declare type ConfigPageElement = string | ConfigVar;
+declare type CreateConfigPages<TIntegrationDefinitionConfigPages> = keyof TIntegrationDefinitionConfigPages extends never ? {
+    [key: string]: ConfigPage;
+} : UnionToIntersection<keyof TIntegrationDefinitionConfigPages extends infer TPageName ? TPageName extends keyof TIntegrationDefinitionConfigPages ? TIntegrationDefinitionConfigPages[TPageName] extends ConfigPage ? {
+    [Key in TPageName]: TIntegrationDefinitionConfigPages[TPageName];
+} : never : never : never>;
+export declare type ConfigPages = CreateConfigPages<IntegrationDefinitionConfigPages>;
+export declare type UserLevelConfigPages = CreateConfigPages<IntegrationDefinitionUserLevelConfigPages>;
+/** Defines attributes of a Config Wizard Page used when deploying an Instance of an Integration. */
+export interface ConfigPage {
+    /** Elements included on this Config Page. */
+    elements: Record<string, ConfigPageElement>;
+    /** Specifies an optional tagline for this Config Page. */
+    tagline?: string;
+}
+export {};

package/dist/types/ConfigPages.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ConfigVars.d.ts

@@ -0,0 +1,241 @@
+import { DataSourceDefinition, ConnectionDefinition, Inputs, DataSourceType, Connection, JSONForm, ObjectFieldMap, ObjectSelection, ConfigVarResultCollection, Schedule, CollectionDataSourceType, DataSourceReference, ConfigPage, ConfigPages, UserLevelConfigPages, ConfigPageElement, ComponentRegistryDataSource, ComponentRegistryConnection } from ".";
+import { Prettify, UnionToIntersection } from "./utils";
+/** Supported data types for Config Vars. */
+export declare type ConfigVarDataType = "string" | "date" | "timestamp" | "picklist" | "code" | "boolean" | "number" | "schedule" | "objectSelection" | "objectFieldMap" | "jsonForm";
+declare type ConfigVarDataTypeDefaultValueMap<TMap extends Record<ConfigVarDataType, unknown> = {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string;
+    code: string;
+    boolean: boolean;
+    number: number;
+    schedule: string;
+    objectSelection: ObjectSelection;
+    objectFieldMap: ObjectFieldMap;
+    jsonForm: JSONForm;
+}> = TMap;
+declare type ConfigVarDataTypeRuntimeValueMap<TMap extends Record<ConfigVarDataType, unknown> = {
+    string: string;
+    date: string;
+    timestamp: string;
+    picklist: string;
+    code: string;
+    boolean: boolean;
+    number: number;
+    schedule: Schedule;
+    objectSelection: ObjectSelection;
+    objectFieldMap: ObjectFieldMap;
+    jsonForm: unknown;
+}> = TMap;
+/** Choices of collection types for multi-value Config Vars. */
+export declare type CollectionType = "valuelist" | "keyvaluelist";
+export declare type PermissionAndVisibilityType = "customer" | "embedded" | "organization";
+declare type ConfigVarSingleDataType = Extract<ConfigVarDataType, "schedule" | "objectSelection" | "objectFieldMap" | "jsonForm">;
+/** Common attribute shared by all types of Config Vars. */
+declare type BaseConfigVar = {
+    /** A unique, unchanging value that is used to maintain identity for the Config Var even if the key changes. */
+    stableKey: string;
+    /** Optional description for this Config Var. */
+    description?: string;
+    /**
+     * Optional value that sets the permission and visibility of the Config Var. @default "customer"
+     *
+     * "customer" - Customers can view and edit the Config Var.
+     * "embedded" - Customers cannot view or update the Config Var as the value will be set programmatically.
+     * "organization" - Customers cannot view or update the Config Var as it will always have a default value or be set by the organization.
+     */
+    permissionAndVisibilityType?: PermissionAndVisibilityType;
+    /** Optional value that specifies whether this Config Var is visible to an Organization deployer. @default true */
+    visibleToOrgDeployer?: boolean;
+};
+declare type GetDynamicProperties<TValue, TCollectionType extends CollectionType | undefined> = TCollectionType extends undefined ? {
+    defaultValue?: TValue;
+    /** Optional value to specify the type of collection if the Config Var is multi-value. */
+    collectionType?: undefined;
+} : TCollectionType extends "valuelist" ? {
+    defaultValue?: TValue[];
+    /** Optional value to specify the type of collection if the Config Var is multi-value. */
+    collectionType: "valuelist";
+} : {
+    defaultValue?: Record<string, TValue> | Array<{
+        key: string;
+        value: TValue;
+    }>;
+    /** Optional value to specify the type of collection if the Config Var is multi-value. */
+    collectionType: "keyvaluelist";
+};
+declare type StandardConfigVarDynamicProperties<TDataType extends ConfigVarDataType> = CollectionType | undefined extends infer TCollectionType ? TCollectionType extends CollectionType | undefined ? TDataType extends ConfigVarSingleDataType ? TCollectionType extends undefined ? GetDynamicProperties<ConfigVarDataTypeDefaultValueMap[TDataType], undefined> : never : GetDynamicProperties<ConfigVarDataTypeDefaultValueMap[TDataType], TCollectionType> : never : never;
+declare type CreateStandardConfigVar<TDataType extends ConfigVarDataType> = BaseConfigVar & StandardConfigVarDynamicProperties<TDataType> & {
+    /** The data type of the Config Var. */
+    dataType: TDataType;
+};
+declare type StringConfigVar = CreateStandardConfigVar<"string">;
+declare type DateConfigVar = CreateStandardConfigVar<"date">;
+declare type TimestampConfigVar = CreateStandardConfigVar<"timestamp">;
+declare type PicklistConfigVar = CreateStandardConfigVar<"picklist"> & {
+    /** List of picklist values. */
+    pickList: string[];
+};
+/** Choices of programming languages that may be used for Config Var code values. */
+export declare type CodeLanguageType = "json" | "xml" | "html";
+declare type CodeConfigVar = CreateStandardConfigVar<"code"> & {
+    /** Value to specify the type of language of a code Config Var. */
+    codeLanguage: CodeLanguageType;
+};
+declare type BooleanConfigVar = CreateStandardConfigVar<"boolean">;
+declare type NumberConfigVar = CreateStandardConfigVar<"number">;
+declare type ScheduleConfigVar = CreateStandardConfigVar<"schedule"> & {
+    /** Optional timezone for the schedule. */
+    timeZone?: string;
+};
+declare type ObjectSelectionConfigVar = CreateStandardConfigVar<"objectSelection">;
+declare type ObjectFieldMapConfigVar = CreateStandardConfigVar<"objectFieldMap">;
+declare type JsonFormConfigVar = CreateStandardConfigVar<"jsonForm">;
+export declare type StandardConfigVar = StringConfigVar | DateConfigVar | TimestampConfigVar | PicklistConfigVar | CodeConfigVar | BooleanConfigVar | NumberConfigVar | ScheduleConfigVar | ObjectSelectionConfigVar | ObjectFieldMapConfigVar | JsonFormConfigVar;
+declare type BaseDataSourceConfigVar<TDataSourceType extends DataSourceType = DataSourceType> = TDataSourceType extends CollectionDataSourceType ? {
+    dataSourceType: TDataSourceType;
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar : TDataSourceType extends Exclude<DataSourceType, CollectionDataSourceType> ? BaseConfigVar & {
+    dataSourceType: TDataSourceType;
+    collectionType?: undefined;
+} : ({
+    dataSourceType: Extract<CollectionDataSourceType, TDataSourceType>;
+    collectionType: CollectionType;
+} & BaseConfigVar) | (BaseConfigVar & {
+    dataSourceType: Extract<Exclude<DataSourceType, CollectionDataSourceType>, TDataSourceType>;
+    collectionType?: undefined;
+});
+declare type DataSourceDefinitionConfigVar = DataSourceType extends infer TDataSourceType ? TDataSourceType extends DataSourceType ? BaseDataSourceConfigVar<TDataSourceType> & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, TDataSourceType>, "display" | "inputs" | "examplePayload" | "detailDataSource"> : never : never;
+declare type DataSourceReferenceConfigVar = ComponentRegistryDataSource extends infer TDataSourceReference ? TDataSourceReference extends ComponentRegistryDataSource ? Omit<BaseDataSourceConfigVar<TDataSourceReference["dataSourceType"]>, "dataSourceType"> & {
+    dataSource: TDataSourceReference["reference"];
+} : never : never;
+/** Defines attributes of a data source Config Var. */
+export declare type DataSourceConfigVar = DataSourceDefinitionConfigVar | DataSourceReferenceConfigVar;
+declare type BaseConnectionConfigVar = BaseConfigVar & {
+    dataType: "connection";
+};
+declare type ConnectionDefinitionConfigVar = BaseConnectionConfigVar & Omit<ConnectionDefinition, "label" | "comments" | "key">;
+declare type OnPremiseConnectionConfigTypeEnum = "allowed" | "disallowed" | "required";
+declare type ConnectionReferenceConfigVar = ComponentRegistryConnection extends infer TConnectionReference ? TConnectionReference extends ComponentRegistryConnection ? BaseConnectionConfigVar & {
+    connection: TConnectionReference["reference"] & ("onPremAvailable" extends keyof TConnectionReference ? TConnectionReference["onPremAvailable"] extends true ? {
+        template?: string;
+        onPremiseConnectionConfig?: OnPremiseConnectionConfigTypeEnum;
+    } : {
+        template?: string;
+        onPremiseConnectionConfig?: undefined;
+    } : {
+        template?: string;
+        onPremiseConnectionConfig?: undefined;
+    });
+} : never : never;
+/** Defines attributes of a Config Var that represents a Connection. */
+export declare type ConnectionConfigVar = ConnectionDefinitionConfigVar | ConnectionReferenceConfigVar;
+export declare type ConfigVar = StandardConfigVar | DataSourceConfigVar | ConnectionConfigVar;
+declare type WithCollectionType<TValue, TCollectionType extends CollectionType | undefined> = undefined | unknown extends TCollectionType ? TValue : TCollectionType extends "valuelist" ? TValue[] : Array<{
+    key: string;
+    value: TValue;
+}>;
+declare type GetDataSourceReference<TComponent extends DataSourceReference["component"], TKey extends DataSourceReference["key"]> = ComponentRegistryDataSource extends infer TDataSourceReference ? TDataSourceReference extends ComponentRegistryDataSource ? TComponent extends TDataSourceReference["reference"]["component"] ? TKey extends TDataSourceReference["reference"]["key"] ? TDataSourceReference : never : never : never : never;
+declare type DataSourceToRuntimeType<TElement extends ConfigPageElement> = TElement extends DataSourceDefinitionConfigVar ? TElement["dataSourceType"] extends infer TType ? TType extends DataSourceType ? ConfigVarDataTypeRuntimeValueMap[TType] : never : never : TElement extends DataSourceReferenceConfigVar ? GetDataSourceReference<TElement["dataSource"]["component"], TElement["dataSource"]["key"]>["dataSourceType"] extends infer TType ? TType extends DataSourceType ? ConfigVarDataTypeRuntimeValueMap[TType] : never : never : never;
+declare type ElementToRuntimeType<TElement extends ConfigPageElement> = TElement extends ConfigVar ? TElement extends ConnectionConfigVar ? Connection : TElement extends StandardConfigVar ? WithCollectionType<ConfigVarDataTypeRuntimeValueMap[TElement["dataType"]], TElement["collectionType"]> : TElement extends DataSourceConfigVar ? WithCollectionType<DataSourceToRuntimeType<TElement>, TElement["collectionType"]> : never : never;
+declare type ExtractConfigVars<TConfigPages extends {
+    [key: string]: ConfigPage;
+}> = keyof TConfigPages extends infer TPageName ? TPageName extends keyof TConfigPages ? TConfigPages[TPageName] extends infer TConfigPage ? TConfigPage extends ConfigPage ? {
+    [Key in keyof TConfigPage["elements"] as Key extends string ? TConfigPage["elements"][Key] extends ConfigVar ? Key : never : never]: ElementToRuntimeType<TConfigPage["elements"][Key]>;
+} : never : never : never : never;
+export declare type ConfigVars = Prettify<UnionToIntersection<ExtractConfigVars<ConfigPages> | ExtractConfigVars<UserLevelConfigPages>>>;
+export declare const isCodeConfigVar: (cv: ConfigVar) => cv is CodeConfigVar;
+export declare const isScheduleConfigVar: (cv: ConfigVar) => cv is ScheduleConfigVar;
+export declare const isDataSourceDefinitionConfigVar: (cv: ConfigVar) => cv is ({
+    dataSourceType: "string";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "string">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | ({
+    dataSourceType: "number";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "number">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | ({
+    dataSourceType: "boolean";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "boolean">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | ({
+    dataSourceType: "code";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "code">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | (BaseConfigVar & {
+    dataSourceType: "objectSelection";
+    collectionType?: undefined;
+} & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "objectSelection">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | (BaseConfigVar & {
+    dataSourceType: "objectFieldMap";
+    collectionType?: undefined;
+} & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "objectFieldMap">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | (BaseConfigVar & {
+    dataSourceType: "jsonForm";
+    collectionType?: undefined;
+} & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "jsonForm">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | ({
+    dataSourceType: "date";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "date">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | ({
+    dataSourceType: "timestamp";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "timestamp">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | ({
+    dataSourceType: "picklist";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "picklist">, "display" | "inputs" | "examplePayload" | "detailDataSource">) | ({
+    dataSourceType: "schedule";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar & Omit<DataSourceDefinition<Inputs, ConfigVarResultCollection, "schedule">, "display" | "inputs" | "examplePayload" | "detailDataSource">);
+export declare const isDataSourceReferenceConfigVar: (cv: unknown) => cv is Omit<({
+    dataSourceType: "string";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar) | ({
+    dataSourceType: "number";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar) | ({
+    dataSourceType: "boolean";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar) | ({
+    dataSourceType: "code";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar) | (BaseConfigVar & {
+    dataSourceType: "objectSelection";
+    collectionType?: undefined;
+}) | (BaseConfigVar & {
+    dataSourceType: "objectFieldMap";
+    collectionType?: undefined;
+}) | (BaseConfigVar & {
+    dataSourceType: "jsonForm";
+    collectionType?: undefined;
+}) | ({
+    dataSourceType: "date";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar) | ({
+    dataSourceType: "timestamp";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar) | ({
+    dataSourceType: "picklist";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar) | ({
+    dataSourceType: "schedule";
+    collectionType?: CollectionType | undefined;
+} & BaseConfigVar), "dataSourceType"> & {
+    dataSource: {
+        component: string;
+        key: string;
+        values: {
+            [x: string]: import("./ComponentRegistry").ConfigVarExpression | import("./ComponentRegistry").ValueExpression<any>;
+        };
+    };
+};
+export declare const isConnectionDefinitionConfigVar: (cv: ConfigVar) => cv is ConnectionDefinitionConfigVar;
+export declare const isConnectionReferenceConfigVar: (cv: unknown) => cv is BaseConfigVar & {
+    dataType: "connection";
+} & {
+    connection: {
+        component: string;
+        key: string;
+        values: {
+            [x: string]: (import("./ComponentRegistry").ConfigVarExpression | import("./ComponentRegistry").ValueExpression<any>) & import("./ComponentRegistry").ConnectionInputPermissionAndVisibility;
+        };
+    } & {
+        template?: string | undefined;
+        onPremiseConnectionConfig?: undefined;
+    };
+};
+export {};

package/dist/types/ConfigVars.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isConnectionReferenceConfigVar = exports.isConnectionDefinitionConfigVar = exports.isDataSourceReferenceConfigVar = exports.isDataSourceDefinitionConfigVar = exports.isScheduleConfigVar = exports.isCodeConfigVar = void 0;
+const _1 = require(".");
+const isCodeConfigVar = (cv) => "dataType" in cv && cv.dataType === "code";
+exports.isCodeConfigVar = isCodeConfigVar;
+const isScheduleConfigVar = (cv) => "dataType" in cv && cv.dataType === "schedule";
+exports.isScheduleConfigVar = isScheduleConfigVar;
+const isDataSourceDefinitionConfigVar = (cv) => "dataSourceType" in cv && "perform" in cv && typeof cv.perform === "function";
+exports.isDataSourceDefinitionConfigVar = isDataSourceDefinitionConfigVar;
+const isDataSourceReferenceConfigVar = (
+// FIXME: Module augmetation causes this to produce a compile error while
+// running `tsd`. I'm pretty uncertain how this happens but leaving as
+// `unkonwn` is fine for now.
+cv) => typeof cv === "object" &&
+    cv !== null &&
+    "dataSource" in cv &&
+    (0, _1.isComponentReference)(cv.dataSource);
+exports.isDataSourceReferenceConfigVar = isDataSourceReferenceConfigVar;
+const isConnectionDefinitionConfigVar = (cv) => "dataType" in cv && cv.dataType === "connection" && "inputs" in cv;
+exports.isConnectionDefinitionConfigVar = isConnectionDefinitionConfigVar;
+const isConnectionReferenceConfigVar = (
+// FIXME: Module augmetation causes this to produce a compile error while
+// running `tsd`. I'm pretty uncertain how this happens but leaving as
+// `unkonwn` is fine for now.
+cv) => typeof cv === "object" &&
+    cv !== null &&
+    "connection" in cv &&
+    (0, _1.isComponentReference)(cv.connection);
+exports.isConnectionReferenceConfigVar = isConnectionReferenceConfigVar;