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

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;

package/dist/types/Inputs.d.ts

@@ -106,48 +106,48 @@ interface KeyValueListCollection<T> {
     /** Default value for this field. */
     default?: KeyValuePair<T>[];
 }
-export declare type StringInputField = BaseInputField & CollectionOptions<string> & {
+export declare type StringInputField = BaseInputField & {
     /** Data type the InputField will collect. */
     type: "string";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
     clean?: InputCleanFunction<unknown>;
-};
-export declare type DataInputField = BaseInputField & CollectionOptions<string> & {
+} & CollectionOptions<string>;
+export declare type DataInputField = BaseInputField & {
     /** Data type the InputField will collect. */
     type: "data";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
     clean?: InputCleanFunction<unknown>;
-};
-export declare type TextInputField = BaseInputField & CollectionOptions<string> & {
+} & CollectionOptions<string>;
+export declare type TextInputField = BaseInputField & {
     /** Data type the InputField will collect. */
     type: "text";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
     clean?: InputCleanFunction<unknown>;
-};
-export declare type PasswordInputField = BaseInputField & CollectionOptions<string> & {
+} & CollectionOptions<string>;
+export declare type PasswordInputField = BaseInputField & {
     /** Data type the InputField will collect. */
     type: "password";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
     clean?: InputCleanFunction<unknown>;
-};
-export declare type BooleanInputField = BaseInputField & CollectionOptions<string> & {
+} & CollectionOptions<string>;
+export declare type BooleanInputField = BaseInputField & {
     /** Data type the InputField will collect. */
     type: "boolean";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
     clean?: InputCleanFunction<unknown>;
-};
+} & CollectionOptions<string>;
 /** Defines attributes of a CodeInputField. */
-export declare type CodeInputField = BaseInputField & CollectionOptions<string> & {
+export declare type CodeInputField = BaseInputField & {
     /** Data type the InputField will collect. */
     type: "code";
     /** Code language for syntax highlighting. For no syntax highlighting, choose "plaintext" */
@@ -156,7 +156,7 @@ export declare type CodeInputField = BaseInputField & CollectionOptions<string>
     model?: InputFieldChoice[];
     /** Clean function */
     clean?: InputCleanFunction<unknown>;
-};
+} & CollectionOptions<string>;
 /** Defines attributes of a ConditionalInputField. */
 export interface ConditionalInputField extends BaseInputField {
     /** Data type the InputField will collect. */
@@ -256,5 +256,5 @@ export interface InputFieldChoice {
 /** InputField collection enumeration */
 export declare type InputFieldCollection = "valuelist" | "keyvaluelist";
 /** Config variable result collection */
-export declare type ConfigVarResultCollection = Record<string, string | Schedule | Connection | JSONForm | ObjectSelection | ObjectFieldMap>;
+export declare type ConfigVarResultCollection = Record<string, string | Schedule | Connection | unknown | ObjectSelection | ObjectFieldMap>;
 export {};