@prismatic-io/spectral 7.8.4 → 8.0.0-preview10

package/dist/testing.js

@@ -15,7 +15,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createHarness = exports.ComponentTestHarness = exports.invokeDataSource = exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
+exports.createHarness = exports.ComponentTestHarness = exports.invokeFlow = exports.invokeDataSource = exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
 const jest_mock_1 = require("jest-mock");
 const createConnection = ({ key }, values, tokenValues) => ({
     configVarKey: "",
@@ -38,46 +38,32 @@ const loggerMock = () => ({
     error: (0, jest_mock_1.spyOn)(console, "error"),
 });
 exports.loggerMock = loggerMock;
-const baseActionContext = {
-    logger: (0, exports.loggerMock)(),
-    instanceState: {},
-    crossFlowState: {},
-    executionState: {},
-    integrationState: {},
-    stepId: "mockStepId",
-    executionId: "mockExecutionId",
-    webhookUrls: {
-        "Flow 1": "https://example.com",
-    },
-    webhookApiKeys: {
-        "Flow 1": ["example-123", "example-456"],
-    },
-    invokeUrl: "https://example.com",
-    customer: {
-        id: "customerId",
-        name: "Customer 1",
-        externalId: "1234",
-    },
-    instance: {
-        id: "instanceId",
-        name: "Instance 1",
-    },
-    user: {
-        id: "userId",
-        email: "user@example.com",
-        name: "User 1",
-        externalId: "1234",
-    },
-    integration: {
-        id: "integrationId",
-        name: "Integration 1",
-        versionSequenceId: "1234",
-    },
-    flow: {
-        id: "flowId",
-        name: "Flow 1",
-    },
-    startedAt: new Date().toISOString(),
+const createActionContext = (context) => {
+    return Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, integrationState: {}, stepId: "mockStepId", executionId: "mockExecutionId", webhookUrls: {
+            "Flow 1": "https://example.com",
+        }, webhookApiKeys: {
+            "Flow 1": ["example-123", "example-456"],
+        }, invokeUrl: "https://example.com", customer: {
+            id: "customerId",
+            name: "Customer 1",
+            externalId: "1234",
+        }, instance: {
+            id: "instanceId",
+            name: "Instance 1",
+        }, user: {
+            id: "userId",
+            email: "user@example.com",
+            name: "User 1",
+            externalId: "1234",
+        }, integration: {
+            id: "integrationId",
+            name: "Integration 1",
+            versionSequenceId: "1234",
+            externalVersion: "1.0.0",
+        }, flow: {
+            id: "flowId",
+            name: "Flow 1",
+        }, startedAt: new Date().toISOString() }, context);
 };
 /**
  * Invokes specified ActionDefinition perform function using supplied params
@@ -85,8 +71,8 @@ const baseActionContext = {
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * action result and a mock logger for asserting logging.
  */
-const invoke = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
+const invoke = ({ perform, }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = createActionContext(context);
     const result = yield perform(realizedContext, params);
     return {
         result,
@@ -138,6 +124,7 @@ const defaultTriggerPayload = () => {
             id: "integrationId",
             name: "Integration 1",
             versionSequenceId: "1234",
+            externalVersion: "1.0.0",
         },
         flow: {
             id: "flowId",
@@ -153,8 +140,8 @@ exports.defaultTriggerPayload = defaultTriggerPayload;
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * trigger result and a mock logger for asserting logging.
  */
-const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
-    const realizedContext = Object.assign(Object.assign({}, baseActionContext), context);
+const invokeTrigger = ({ perform, }, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = createActionContext(context);
     const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const realizedParams = params || {};
     const result = yield perform(realizedContext, realizedPayload, realizedParams);
@@ -193,6 +180,27 @@ const invokeDataSource = ({ perform }, params, context) => __awaiter(void 0, voi
     return result;
 });
 exports.invokeDataSource = invokeDataSource;
+/**
+ * Invokes specified Flow of a Code Native Integration using supplied params.
+ * Runs the Trigger and then the Action function and returns the result of the Action.
+ */
+const invokeFlow = (flow, context, payload) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = createActionContext(context);
+    const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
+    const params = {
+        onTrigger: { results: null },
+    };
+    if ("onTrigger" in flow) {
+        const triggerResult = yield flow.onTrigger(realizedContext, realizedPayload, params);
+        params.onTrigger = { results: triggerResult === null || triggerResult === void 0 ? void 0 : triggerResult.payload };
+    }
+    const result = yield flow.onExecution(realizedContext, params);
+    return {
+        result,
+        loggerMock: realizedContext.logger,
+    };
+});
+exports.invokeFlow = invokeFlow;
 class ComponentTestHarness {
     constructor(component) {
         this.component = component;
@@ -215,7 +223,7 @@ class ComponentTestHarness {
     trigger(key, payload, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const trigger = this.component.triggers[key];
-            return trigger.perform(this.buildContext(baseActionContext, context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
+            return trigger.perform(createActionContext(context), Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), this.buildParams(trigger.inputs, params));
         });
     }
     triggerOnInstanceDeploy(key, params, context) {
@@ -224,7 +232,7 @@ class ComponentTestHarness {
             if (!trigger.onInstanceDeploy) {
                 throw new Error("Trigger does not support onInstanceDeploy");
             }
-            return trigger.onInstanceDeploy(this.buildContext(baseActionContext, context), this.buildParams(trigger.inputs, params));
+            return trigger.onInstanceDeploy(createActionContext(context), this.buildParams(trigger.inputs, params));
         });
     }
     triggerOnInstanceDelete(key, params, context) {
@@ -233,13 +241,13 @@ class ComponentTestHarness {
             if (!trigger.onInstanceDelete) {
                 throw new Error("Trigger does not support onInstanceDelete");
             }
-            return trigger.onInstanceDelete(this.buildContext(baseActionContext, context), this.buildParams(trigger.inputs, params));
+            return trigger.onInstanceDelete(createActionContext(context), this.buildParams(trigger.inputs, params));
         });
     }
     action(key, params, context) {
         return __awaiter(this, void 0, void 0, function* () {
             const action = this.component.actions[key];
-            return action.perform(this.buildContext(baseActionContext, context), this.buildParams(action.inputs, params));
+            return action.perform(createActionContext(context), this.buildParams(action.inputs, params));
         });
     }
     dataSource(key, params, context) {

package/dist/types/ActionDefinition.d.ts

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

package/dist/types/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

@@ -239,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,269 @@
+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;
+    /** 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;
+    /** 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 = {}));