@prismatic-io/spectral 7.10.0 → 8.0.0-preview11

package/dist/types/ActionPerformFunction.d.ts

@@ -1,8 +1,8 @@
-import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger, Instance, Customer, User, Integration, Flow } 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, THasConfigVars extends boolean, TAllowsBranching extends boolean | undefined, TReturn extends ActionPerformReturn<TAllowsBranching, unknown>> = (context: ActionContext<TConfigVars, THasConfigVars>, 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 = ConfigVarResultCollection, THasConfigVars extends boolean = false> = {
     /** Logger for permanent logging; console calls are also captured */
     logger: ActionLogger;
     /** A a flow-specific key/value store that may be used to store small amounts of data that is persisted between Instance executions */
@@ -24,15 +24,18 @@ export interface ActionContext {
     /** The URL used to invoke the current execution */
     invokeUrl: string;
     /** Contains attributes of the Customer for whom an Instance is being executed. */
-    customer: Customer;
+    customer: CustomerAttributes;
     /** Contains attributes of the Instance that is being executed. */
-    instance: Instance;
+    instance: InstanceAttributes;
     /** Contains attributes of the User for whom a User Level Configuration is being used. */
-    user: User;
+    user: UserAttributes;
     /** Contains attributes of the Integration that is being executed. */
-    integration: Integration;
+    integration: IntegrationAttributes;
     /** Contains attributes of the Flow that is being executed. */
-    flow: Flow;
+    flow: FlowAttributes;
     /** The time in UTC that execution started. */
     startedAt: string;
-}
+} & (THasConfigVars extends true ? {
+    /** Key/value collection of config variables of the integration. */
+    configVars: TConfigVars;
+} : Record<string, never>);

package/dist/types/ComponentDefinition.d.ts

@@ -13,9 +13,9 @@ 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>>;
     /** Specifies the supported Connections of this Component. */

package/dist/types/{Customer.d.ts → CustomerAttributes.d.ts}

@@ -1,5 +1,5 @@
 /** Contains attributes of the Customer for whom an Instance is being executed. */
-export interface Customer {
+export interface CustomerAttributes {
     id: string;
     externalId: string;
     name: string;

package/dist/types/DataSourcePerformFunction.d.ts

@@ -1,10 +1,10 @@
-import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters, ActionLogger, Customer, Instance, User } from ".";
+import { Inputs, DataSourceResult, DataSourceType, ActionInputParameters, ActionLogger, CustomerAttributes, InstanceAttributes, UserAttributes } from ".";
 /** Context provided to perform method containing helpers and contextual data */
 export interface DataSourceContext {
     logger: ActionLogger;
-    customer: Customer;
-    instance: Instance;
-    user: User;
+    customer: CustomerAttributes;
+    instance: InstanceAttributes;
+    user: UserAttributes;
 }
 /** 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>>;

package/dist/types/{Flow.d.ts → FlowAttributes.d.ts}

@@ -1,5 +1,5 @@
 /** Contains attributes of the Flow that is being executed. */
-export interface Flow {
+export interface FlowAttributes {
     id: string;
     name: string;
 }

package/dist/types/Inputs.d.ts

@@ -1,18 +1,5 @@
 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;
@@ -79,76 +66,81 @@ interface BaseInputField {
     /** Indicate if this InputField is required. */
     required?: boolean;
 }
-declare type CollectionOptions<T> = SingleValue<T> | ValueListCollection<T> | KeyValueListCollection<T>;
-interface SingleValue<T> {
-    /** Collection type of the InputField */
-    collection?: undefined;
-    /** Default value for this field. */
-    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> & {
+export interface StringInputField extends BaseInputField {
     /** Data type the InputField will collect. */
     type: "string";
+    /** 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<unknown>;
-};
-export declare type DataInputField = BaseInputField & CollectionOptions<string> & {
+    clean?: InputCleanFunction<this["default"]>;
+}
+export interface DataInputField extends BaseInputField {
     /** 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<unknown>;
-};
-export declare type TextInputField = BaseInputField & CollectionOptions<string> & {
+    clean?: InputCleanFunction<this["default"]>;
+}
+export interface TextInputField extends BaseInputField {
     /** 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<unknown>;
-};
-export declare type PasswordInputField = BaseInputField & CollectionOptions<string> & {
+    clean?: InputCleanFunction<this["default"]>;
+}
+export interface PasswordInputField extends BaseInputField {
     /** 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<unknown>;
-};
-export declare type BooleanInputField = BaseInputField & CollectionOptions<string> & {
+    clean?: InputCleanFunction<this["default"]>;
+}
+export interface BooleanInputField extends BaseInputField {
     /** 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<unknown>;
-};
+    clean?: InputCleanFunction<this["default"]>;
+}
 /** Defines attributes of a CodeInputField. */
-export declare type CodeInputField = BaseInputField & CollectionOptions<string> & {
+export interface CodeInputField extends BaseInputField {
     /** 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<unknown>;
-};
+    clean?: InputCleanFunction<this["default"]>;
+}
 /** Defines attributes of a ConditionalInputField. */
 export interface ConditionalInputField extends BaseInputField {
     /** Data type the InputField will collect. */
@@ -247,4 +239,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>;
 export {};

package/dist/types/{Instance.d.ts → InstanceAttributes.d.ts}

@@ -1,5 +1,5 @@
 /** Contains attributes of the Instance that is being executed. */
-export interface Instance {
+export interface InstanceAttributes {
     id: string;
     name: string;
 }

package/dist/types/{Integration.d.ts → IntegrationAttributes.d.ts}

@@ -1,6 +1,7 @@
 /** Contains attributes of the Integration that is being executed. */
-export interface Integration {
+export interface IntegrationAttributes {
     id: string;
     name: string;
     versionSequenceId: string;
+    externalVersion: string;
 }

package/dist/types/IntegrationDefinition.d.ts

@@ -0,0 +1,273 @@
+import { DataSourceDefinition, ConnectionDefinition, ActionPerformFunction, ActionPerformReturn, TriggerEventFunction, TriggerPerformFunction, Inputs, TriggerResult, DataSourceType, Connection as ConnectionResult, TriggerPayload } from ".";
+export declare type ConfigVarCollection = Record<string, ConfigVar>;
+export declare type ConfigVarDefinitionsToResults<TConfigVars extends ConfigVarCollection> = {
+    [Key in keyof TConfigVars]: TConfigVars[Key]["inputs"] extends Record<string, any> ? ConnectionResult : string;
+};
+/** Defines attributes of a Code-Native Integration. */
+export declare type IntegrationDefinition<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = {
+    /** The unique name for this Integration. */
+    name: string;
+    /** Optional description for this Integration. */
+    description?: string;
+    /** Optional path to icon to use for this Integration. Path should be relative to the built Integration source. */
+    iconPath?: string;
+    /** Optional category for this Integration. */
+    category?: string;
+    /** Optional documentation for this Integration. */
+    documentation?: string;
+    /** Optional version identifier for this Integration. */
+    version?: string;
+    /** Optional labels for this Integration. */
+    labels?: string[];
+    /** Optional endpoint type used by Instances of this Integration.
+     *  A Preprocess Flow Config must be specified when using anything other than 'Flow Specific'.
+     *  @default EndpointType.FlowSpecific. */
+    endpointType?: EndpointType;
+    /** Optional Preprocess Flow configuration for when the Trigger payload contains the flow routing attributes.
+     *  Cannot specify this if a Preprocess Flow is also configured. */
+    triggerPreprocessFlowConfig?: PreprocessFlowConfig;
+    /** Flows for this Integration. */
+    flows: Flow<TConfigVars>[];
+    /** Config Vars used on this Integration. */
+    configVars?: TConfigVars;
+    /** Config Wizard Pages for this Integration. */
+    configPages?: ConfigPage<TConfigVars>[];
+    /** Specifies any Data Sources that are defined as part of this Integration. */
+    dataSources?: Record<string, CodeNativeDataSource>;
+};
+/** Defines attributes of a Flow of a Code-Native Integration. */
+export interface Flow<TConfigVars extends ConfigVarCollection = ConfigVarCollection, TTriggerPayload extends TriggerPayload = TriggerPayload> {
+    /** The unique name for this Flow. */
+    name: string;
+    /** A unique, unchanging value that is used to maintain identity for the Flow even if the name changes. */
+    stableKey: string;
+    /** Optional description for this Flow. */
+    description?: string;
+    /** Optional Preprocess Flow configuration for when the result of this Flow contains the flow routing attributes. Only one Flow per Integration may define this. */
+    preprocessFlowConfig?: PreprocessFlowConfig;
+    /** Optional value that specifies whether this Flow is synchronous. @default false */
+    isSynchronous?: boolean;
+    /** Optional Retry Configuration for this Flow. */
+    retryConfig?: RetryConfig;
+    /** Optional security configuration to use for the endpoint of this Flow. @default EndpointSecurityType.CustomerOptional */
+    endpointSecurityType?: EndpointSecurityType;
+    /** Optional list of API key(s) to use for the endpoint of this Flow when the endpoint security type is EndpointSecurityType.Organization. */
+    organizationApiKeys?: string[];
+    /** Optional schedule configuration that defines the frequency with which this Flow will be automatically executed. */
+    schedule?: FlowSchedule;
+    /** Optional error handling configuration. */
+    errorConfig?: StepErrorConfig;
+    /** Specifies the trigger function for this Flow, which returns a payload and optional HTTP response. */
+    onTrigger: TriggerPerformFunction<Inputs, ConfigVarDefinitionsToResults<TConfigVars>, true, false, TriggerResult<false, TTriggerPayload>>;
+    /** Specifies the function to execute when an Instance of this Integration is deployed. */
+    onInstanceDeploy?: TriggerEventFunction<Inputs, ConfigVarDefinitionsToResults<TConfigVars>, true>;
+    /** Specifies the function to execute when an Instance of an Integration is deleted. */
+    onInstanceDelete?: TriggerEventFunction<Inputs, ConfigVarDefinitionsToResults<TConfigVars>, true>;
+    /** Specifies the main function for this Flow */
+    onExecution: ActionPerformFunction<{
+        onTrigger: {
+            type: "data";
+            label: string;
+            clean: (value: unknown) => {
+                results: TTriggerPayload;
+            };
+        };
+    }, ConfigVarDefinitionsToResults<TConfigVars>, true, false, ActionPerformReturn<false, unknown>>;
+}
+/** Defines attributes of a Data Source that is defined as part of a Code Native Integration. */
+export declare type CodeNativeDataSource = Pick<DataSourceDefinition<Inputs, DataSourceType>, "display" | "perform" | "dataSourceType" | "detailDataSource">;
+/** Common attribute shared by all types of Config Vars. */
+declare type BaseConfigVar = {
+    /** The unique key for this Config Var. */
+    key: string;
+    /** 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 specifies whether this Config Var is only configurable by Organization users. @default false  */
+    orgOnly?: boolean;
+    /** Optional input values for this Config Var. */
+    inputs?: InputValues;
+    /** Optional value that specifies whether this Config Var is visible to an Organization deployer. @default true */
+    visibleToOrgDeployer?: boolean;
+    /** Optional value that specifies whether this Config Var is visible to a Customer deployer. @default true */
+    visibleToCustomerDeployer?: boolean;
+};
+/** Defines attributes of a standard Config Var. */
+export declare type StandardConfigVar = BaseConfigVar & {
+    /** Optional default value for the Config Var. */
+    defaultValue?: string;
+    /** The data type of the Config Var. */
+    dataType: ConfigVarDataType;
+    /** Optional list of picklist values if the Config Var is a multi-choice selection value. */
+    pickList?: string[];
+    /** Optional schedule type that defines the cadence of the schedule. */
+    scheduleType?: ScheduleType;
+    /** Optional value to use as a timezone if the Config Var is a schedule value. */
+    timeZone?: string;
+    /** Optional value to specify the type of language if the Config Var is a code value. */
+    codeLanguage?: CodeLanguageType;
+    /** Optional value to specify the type of collection if the Config Var is multi-value. */
+    collectionType?: CollectionType;
+    /** Optional value to specify the key of a Data Source defined in this CNI
+     *  where the Config Var sources its values. */
+    dataSource?: string;
+};
+/** Defines attributes of a Config Var that represents a Connection. */
+export declare type ConnectionConfigVar = Omit<BaseConfigVar, "description" | "inputs"> & ConnectionDefinition;
+export declare type ConfigVar = StandardConfigVar | ConnectionConfigVar;
+/** Defines attributes of a Config Wizard Page used when deploying an Instance of an Integration. */
+export declare type ConfigPage<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = {
+    /** The unique name for this Config Page. */
+    name: string;
+    /** Specifies an optional tagline for this Config Page. */
+    tagline?: string;
+    /** Optional value that specifies whether this Config Page is configured as
+     *  part of User Level Configuration. @default false */
+    userLevelConfigured?: boolean;
+    /** Elements included on this Config Page. */
+    elements: ConfigPageElement<TConfigVars>[];
+};
+/** Defines attributes of Inputs for Connections, Actions, Triggers,
+ *  Data Sources, and Config Vars. */
+export declare type InputValues = Record<string, InputValue>;
+export declare type InputValue = SimpleInputValue | ComplexInputValue;
+export declare type SimpleInputValue = {
+    name?: string;
+    type: SimpleInputValueType;
+    value: string;
+    meta?: Record<string, unknown>;
+};
+export declare type ComplexInputValue = {
+    name?: string;
+    type: "complex";
+    value: ComplexInputValueType;
+    meta?: Record<string, unknown>;
+};
+export declare type ComplexInputValueType = (string | InputValue | ComplexInputValueType)[];
+/** Defines attributes of an Element that appears on a Config Wizard Page. */
+export declare type ConfigPageElement<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = HTMLConfigPageElement | JSONFormConfigPageElement | ConfigVarPageElement<TConfigVars>;
+declare type HTMLConfigPageElement = {
+    type: ConfigPageElementType.HTML;
+    value: string;
+};
+declare type JSONFormConfigPageElement = {
+    type: ConfigPageElementType.JSONForm;
+    value: string;
+};
+declare type ConfigVarPageElement<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = {
+    type: ConfigPageElementType.ConfigVar;
+    value: keyof TConfigVars;
+};
+/** Defines attributes of a Preprocess Flow Configuration used by a Flow of an Integration. */
+export declare type PreprocessFlowConfig = {
+    /** Name of the field in the data payload returned by the Preprocess Flow to use for a Flow Name. */
+    flowNameField: string;
+    /** Optional name of the field in the data payload returned by the Preprocess Flow to use for an External Customer Id. */
+    externalCustomerIdField?: string;
+    /** Optional name of the field in the data payload returned by the Preprocess Flow to use for an External Customer User Id. */
+    externalCustomerUserIdField?: string;
+};
+/** Defines attributes of a Retry Configuration used by a Flow of an Integration. */
+export declare type RetryConfig = {
+    /** The maximum number of retry attempts. Must be between 0 and 10. */
+    maxAttempts: number;
+    /** The delay in minutes to wait between retry attempts. Must be between 0 and 60. */
+    delayMinutes: number;
+    /** Specifies whether to use exponential backoff to calculate the delay between retry attempts. */
+    usesExponentialBackoff: boolean;
+    /** Name of the field in the data payload returned by the Flow Trigger to use as a Unique Request ID for retry request cancellation. */
+    uniqueRequestIdField?: string;
+};
+/** Defines attributes of a Step Error Configuration used to determine how to handle errors during Flow step execution. */
+export declare type StepErrorConfig = {
+    /** Defines the type of error handler. */
+    errorHandlerType: StepErrorHandlerType;
+    /** The maximum number of retry attempts. Must be between 0 and 5. */
+    maxAttempts?: number;
+    /** The delay in seconds to wait between retry attempts. Must be between 0 and 60. */
+    delaySeconds?: number;
+    /** Specifies whether to use exponential backoff to calculate the delay between retry attempts. @default false */
+    usesExponentialBackoff?: boolean;
+    /** Specifies whether to ignore the final error after the final retry attempt. @default false */
+    ignoreFinalError?: boolean;
+};
+/** Defines attributes of a Schedule that controls how often a Flow is automatically executed. */
+export declare type FlowSchedule = {
+    /** The cron expression to use for defining an execution schedule. */
+    cronExpression: string;
+    /** Specifies an optional value to use as the timezone. */
+    timeZone?: string;
+} | {
+    /** The key of the Config Var whose value will define the execution schedule. */
+    configVarKey: string;
+    /** Specifies an optional value to use as the timezone. */
+    timeZone?: string;
+};
+/** Choices of Simple Input Value Types that may be used by Simple Input Values. */
+export declare enum SimpleInputValueType {
+    Value = "value",
+    Reference = "reference",
+    ConfigVar = "configVar",
+    Template = "template"
+}
+/** Choices of Endpoint Types that may be used by Instances of an Integration. */
+export declare enum EndpointType {
+    FlowSpecific = "flow_specific",
+    InstanceSpecific = "instance_specific",
+    SharedInstance = "shared_instance"
+}
+/** Choices of Endpoint Security Types that may be used by endpoints of a Flow. */
+export declare enum EndpointSecurityType {
+    Unsecured = "unsecured",
+    CustomerOptional = "customer_optional",
+    CustomerRequired = "customer_required",
+    Organization = "organization"
+}
+/** Choices of Config Page Element Types that may be used for Elements on a Config Wizard Page. */
+export declare enum ConfigPageElementType {
+    ConfigVar = "configVar",
+    HTML = "htmlElement",
+    JSONForm = "jsonForm"
+}
+/** Choices of Step Error Handlers that define the behavior when a step error occurs. */
+export declare enum StepErrorHandlerType {
+    Fail = "fail",
+    Ignore = "ignore",
+    Retry = "retry"
+}
+/** Choices for Schedules that add context for the cadence of a given schedule. */
+export declare enum ScheduleType {
+    None = "none",
+    Custom = "custom",
+    Minute = "minute",
+    Hour = "hour",
+    Day = "day",
+    Week = "week"
+}
+/** Supported data types for Config Vars. */
+export declare enum ConfigVarDataType {
+    String = "string",
+    Date = "date",
+    Timestamp = "timestamp",
+    Picklist = "picklist",
+    Schedule = "schedule",
+    Code = "code",
+    Boolean = "boolean",
+    Number = "number",
+    ObjectSelection = "objectSelection",
+    ObjectFieldMap = "objectFieldMap",
+    JSONForm = "jsonForm"
+}
+/** Choices of programming languages that may be used for Config Var code values. */
+export declare enum CodeLanguageType {
+    JSON = "json",
+    XML = "xml",
+    HTML = "html"
+}
+/** Choices of collection types for multi-value Config Vars. */
+export declare enum CollectionType {
+    ValueList = "valuelist",
+    KeyValueList = "keyvaluelist"
+}
+export {};

package/dist/types/IntegrationDefinition.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionType = exports.CodeLanguageType = exports.ConfigVarDataType = exports.ScheduleType = exports.StepErrorHandlerType = exports.ConfigPageElementType = exports.EndpointSecurityType = exports.EndpointType = exports.SimpleInputValueType = void 0;
+/** Choices of Simple Input Value Types that may be used by Simple Input Values. */
+var SimpleInputValueType;
+(function (SimpleInputValueType) {
+    SimpleInputValueType["Value"] = "value";
+    SimpleInputValueType["Reference"] = "reference";
+    SimpleInputValueType["ConfigVar"] = "configVar";
+    SimpleInputValueType["Template"] = "template";
+})(SimpleInputValueType = exports.SimpleInputValueType || (exports.SimpleInputValueType = {}));
+/** Choices of Endpoint Types that may be used by Instances of an Integration. */
+var EndpointType;
+(function (EndpointType) {
+    EndpointType["FlowSpecific"] = "flow_specific";
+    EndpointType["InstanceSpecific"] = "instance_specific";
+    EndpointType["SharedInstance"] = "shared_instance";
+})(EndpointType = exports.EndpointType || (exports.EndpointType = {}));
+/** Choices of Endpoint Security Types that may be used by endpoints of a Flow. */
+var EndpointSecurityType;
+(function (EndpointSecurityType) {
+    EndpointSecurityType["Unsecured"] = "unsecured";
+    EndpointSecurityType["CustomerOptional"] = "customer_optional";
+    EndpointSecurityType["CustomerRequired"] = "customer_required";
+    EndpointSecurityType["Organization"] = "organization";
+})(EndpointSecurityType = exports.EndpointSecurityType || (exports.EndpointSecurityType = {}));
+/** Choices of Config Page Element Types that may be used for Elements on a Config Wizard Page. */
+var ConfigPageElementType;
+(function (ConfigPageElementType) {
+    ConfigPageElementType["ConfigVar"] = "configVar";
+    ConfigPageElementType["HTML"] = "htmlElement";
+    ConfigPageElementType["JSONForm"] = "jsonForm";
+})(ConfigPageElementType = exports.ConfigPageElementType || (exports.ConfigPageElementType = {}));
+/** Choices of Step Error Handlers that define the behavior when a step error occurs. */
+var StepErrorHandlerType;
+(function (StepErrorHandlerType) {
+    StepErrorHandlerType["Fail"] = "fail";
+    StepErrorHandlerType["Ignore"] = "ignore";
+    StepErrorHandlerType["Retry"] = "retry";
+})(StepErrorHandlerType = exports.StepErrorHandlerType || (exports.StepErrorHandlerType = {}));
+/** Choices for Schedules that add context for the cadence of a given schedule. */
+var ScheduleType;
+(function (ScheduleType) {
+    ScheduleType["None"] = "none";
+    ScheduleType["Custom"] = "custom";
+    ScheduleType["Minute"] = "minute";
+    ScheduleType["Hour"] = "hour";
+    ScheduleType["Day"] = "day";
+    ScheduleType["Week"] = "week";
+})(ScheduleType = exports.ScheduleType || (exports.ScheduleType = {}));
+/** Supported data types for Config Vars. */
+var ConfigVarDataType;
+(function (ConfigVarDataType) {
+    ConfigVarDataType["String"] = "string";
+    ConfigVarDataType["Date"] = "date";
+    ConfigVarDataType["Timestamp"] = "timestamp";
+    ConfigVarDataType["Picklist"] = "picklist";
+    ConfigVarDataType["Schedule"] = "schedule";
+    ConfigVarDataType["Code"] = "code";
+    ConfigVarDataType["Boolean"] = "boolean";
+    ConfigVarDataType["Number"] = "number";
+    ConfigVarDataType["ObjectSelection"] = "objectSelection";
+    ConfigVarDataType["ObjectFieldMap"] = "objectFieldMap";
+    ConfigVarDataType["JSONForm"] = "jsonForm";
+})(ConfigVarDataType = exports.ConfigVarDataType || (exports.ConfigVarDataType = {}));
+/** Choices of programming languages that may be used for Config Var code values. */
+var CodeLanguageType;
+(function (CodeLanguageType) {
+    CodeLanguageType["JSON"] = "json";
+    CodeLanguageType["XML"] = "xml";
+    CodeLanguageType["HTML"] = "html";
+})(CodeLanguageType = exports.CodeLanguageType || (exports.CodeLanguageType = {}));
+/** Choices of collection types for multi-value Config Vars. */
+var CollectionType;
+(function (CollectionType) {
+    CollectionType["ValueList"] = "valuelist";
+    CollectionType["KeyValueList"] = "keyvaluelist";
+})(CollectionType = exports.CollectionType || (exports.CollectionType = {}));

package/dist/types/TriggerDefinition.d.ts

@@ -1,4 +1,4 @@
-import { ActionDisplayDefinition, TriggerPerformFunction, TriggerEventFunction, Inputs, TriggerResult } from ".";
+import { ActionDisplayDefinition, TriggerPerformFunction, TriggerEventFunction, Inputs, TriggerResult, ConfigVarResultCollection, TriggerPayload } from ".";
 declare const optionChoices: readonly ["invalid", "valid", "required"];
 export declare type TriggerOptionChoice = typeof optionChoices[number];
 export declare const TriggerOptionChoices: TriggerOptionChoice[];
@@ -6,15 +6,15 @@ export declare const TriggerOptionChoices: TriggerOptionChoice[];
  * TriggerDefinition is the type of the object that is passed in to `trigger` function to
  * define a component trigger.
  */
-export interface TriggerDefinition<TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching>> {
+export interface TriggerDefinition<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>> {
     /** Defines how the Trigger is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Trigger is invoked. */
-    perform: TriggerPerformFunction<TInputs, TAllowsBranching, TResult>;
+    perform: TriggerPerformFunction<TInputs, TConfigVars, false, TAllowsBranching, TResult>;
     /** Function to execute when an Instance of an Integration with a Flow that uses this Trigger is deployed. */
-    onInstanceDeploy?: TriggerEventFunction<TInputs>;
+    onInstanceDeploy?: TriggerEventFunction<TInputs, TConfigVars, false>;
     /** Function to execute when an Instance of an Integration with a Flow that uses this Trigger is deleted. */
-    onInstanceDelete?: TriggerEventFunction<TInputs>;
+    onInstanceDelete?: TriggerEventFunction<TInputs, TConfigVars, false>;
     /** InputFields to present in the Prismatic interface for configuration of this Trigger. */
     inputs: TInputs;
     /** Specifies whether this Trigger supports executing the Integration on a recurring schedule. */

package/dist/types/TriggerEventFunction.d.ts

@@ -1,4 +1,4 @@
-import { Inputs, ActionContext, ActionInputParameters } from ".";
+import { Inputs, ActionContext, ActionInputParameters, ConfigVarResultCollection } from ".";
 export declare type TriggerEventFunctionReturn = {
     /** An optional object, the keys and values of which will be persisted in the flow-specific instanceState and available for subsequent actions and executions */
     instanceState?: Record<string, unknown>;
@@ -10,4 +10,4 @@ export declare type TriggerEventFunctionReturn = {
     integrationState?: Record<string, unknown>;
 };
 /** Definition of the function to execute when a Trigger Event occurs. */
-export declare type TriggerEventFunction<TInputs extends Inputs> = (context: ActionContext, params: ActionInputParameters<TInputs>) => Promise<void | TriggerEventFunctionReturn>;
+export declare type TriggerEventFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, THasConfigVars extends boolean> = (context: ActionContext<TConfigVars, THasConfigVars>, params: ActionInputParameters<TInputs>) => Promise<void | TriggerEventFunctionReturn>;