@prismatic-io/spectral 7.8.4 → 8.0.0-preview3

package/dist/index.d.ts

@@ -3,8 +3,17 @@
  * authors create inputs, actions, and components that can
  * be processed by the Prismatic API.
  */
-import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition } from "./types";
-import { convertComponent } from "./serverTypes/convert";
+import { ActionDefinition, InputFieldDefinition, ComponentDefinition, DefaultConnectionDefinition, OAuth2ConnectionDefinition, Inputs, TriggerDefinition, ActionPerformReturn, TriggerResult, DataSourceDefinition, IntegrationDefinition } from "./types";
+import { convertComponent, convertIntegration } from "./serverTypes/convert";
+/**
+ * This function creates a Integration object that can be
+ * imported into the Prismatic API. For information on using
+ * this function to write code native integrations, see
+ * https://prismatic.io/docs/code-native-integrations/.
+ * @param definition An IntegrationDefinition type object.
+ * @returns This function returns an integration object that has the shape the Prismatic API expects.
+ */
+export declare const integration: (definition: IntegrationDefinition) => ReturnType<typeof convertIntegration>;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using
@@ -56,14 +65,6 @@ export declare const dataSource: <TInputs extends Inputs, TDataSourceType extend
     boolean: boolean;
     number: number;
     connection: import("./types").Connection;
-    /**
-     * This function creates a component object that can be
-     * imported into the Prismatic API. For information on using
-     * this function to write custom components, see
-     * https://prismatic.io/docs/custom-components/writing-custom-components/#exporting-a-component.
-     * @param definition A ComponentDefinition type object, including display information, unique key, and a set of actions the component implements.
-     * @returns This function returns a component object that has the shape the Prismatic API expects.
-     */
     objectSelection: import("./types").ObjectSelection;
     objectFieldMap: import("./types").ObjectFieldMap;
     jsonForm: import("./types").JSONForm;

package/dist/index.js

@@ -22,8 +22,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = void 0;
+exports.testing = exports.util = exports.oauth2Connection = exports.connection = exports.input = exports.dataSource = exports.trigger = exports.action = exports.component = exports.integration = void 0;
 const convert_1 = require("./serverTypes/convert");
+/**
+ * This function creates a Integration object that can be
+ * imported into the Prismatic API. For information on using
+ * this function to write code native integrations, see
+ * https://prismatic.io/docs/code-native-integrations/.
+ * @param definition An IntegrationDefinition type object.
+ * @returns This function returns an integration object that has the shape the Prismatic API expects.
+ */
+const integration = (definition) => (0, convert_1.convertIntegration)(definition);
+exports.integration = integration;
 /**
  * This function creates a component object that can be
  * imported into the Prismatic API. For information on using

package/dist/serverTypes/convert.d.ts

@@ -1,3 +1,4 @@
-import { ComponentDefinition } from "../types";
+import { ComponentDefinition, IntegrationDefinition } from "../types";
 import { Component as ServerComponent } from ".";
 export declare const convertComponent: <TPublic extends boolean, TKey extends string>({ connections, actions, triggers, dataSources, hooks, ...definition }: ComponentDefinition<TPublic, TKey>) => ServerComponent;
+export declare const convertIntegration: (definition: IntegrationDefinition) => ServerComponent;

package/dist/serverTypes/convert.js

@@ -10,8 +10,13 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertComponent = void 0;
+exports.convertIntegration = exports.convertComponent = void 0;
+const yaml_1 = __importDefault(require("yaml"));
+const uuid_1 = require("uuid");
 const types_1 = require("../types");
 const perform_1 = require("./perform");
 const convertInput = (key, _a) => {
@@ -77,3 +82,161 @@ const convertComponent = (_a) => {
     return Object.assign(Object.assign({}, definition), { connections: connections.map(convertConnection), actions: convertedActions, triggers: convertedTriggers, dataSources: convertedDataSources });
 };
 exports.convertComponent = convertComponent;
+const convertIntegration = (definition) => {
+    // Generate a unique reference key that will be used to reference the
+    // actions, triggers, data sources, and connections that are created
+    // inline as part of the integration definition.
+    const referenceKey = (0, uuid_1.v4)();
+    return Object.assign(Object.assign({}, codeNativeIntegrationComponent(definition, referenceKey)), { codeNativeIntegrationYAML: codeNativeIntegrationYaml(definition, referenceKey) });
+};
+exports.convertIntegration = convertIntegration;
+const codeNativeIntegrationYaml = ({ name, description, category, documentation, configVars, endpointType, preprocessFlowName, externalCustomerIdField, externalCustomerUserIdField, flowNameField, flows, configPages, }, referenceKey) => {
+    const DEFINITION_VERSION = 7;
+    // Transform the IntegrationDefinition into the structure that is appropriate
+    // for generating YAML, which will then be used by the Prismatic API to import
+    // the integration as a Code Native Integration.
+    const result = {
+        definitionVersion: DEFINITION_VERSION,
+        isCodeNative: true,
+        name,
+        description,
+        category,
+        documentation,
+        requiredConfigVars: configVars === null || configVars === void 0 ? void 0 : configVars.map((configVar) => convertConfigVar(configVar, referenceKey)),
+        endpointType,
+        preprocessFlowName,
+        externalCustomerIdField: fieldNameToReferenceInput("action", externalCustomerIdField),
+        externalCustomerUserIdField: fieldNameToReferenceInput("action", externalCustomerUserIdField),
+        flowNameField: fieldNameToReferenceInput("payload", flowNameField),
+        flows: flows.map((flow) => convertFlow(flow, referenceKey)),
+        configPages,
+    };
+    return yaml_1.default.stringify(result);
+};
+/** Converts a Flow into the structure necessary for YAML generation. */
+const convertFlow = (flow, referenceKey) => {
+    const result = Object.assign({}, flow);
+    delete result.trigger;
+    delete result.action;
+    const triggerStep = {
+        name: "trigger",
+        isTrigger: true,
+        errorConfig: "errorConfig" in flow.trigger ? flow.trigger.errorConfig : undefined,
+    };
+    if ("perform" in flow.trigger) {
+        triggerStep.action = {
+            key: flowFunctionKey(flow.name, "trigger"),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        };
+    }
+    else {
+        triggerStep.action = {
+            key: flow.trigger.key,
+            component: flow.trigger.component,
+        };
+    }
+    if ("inputs" in flow.trigger) {
+        triggerStep.inputs = flow.trigger.inputs;
+        delete result.inputs;
+    }
+    if ("schedule" in flow && typeof flow.schedule === "object") {
+        triggerStep.schedule = {
+            type: "cronExpression" in flow.schedule
+                ? types_1.SimpleInputValueType.Value
+                : types_1.SimpleInputValueType.ConfigVar,
+            value: "cronExpression" in flow.schedule
+                ? flow.schedule.cronExpression
+                : flow.schedule.configVarKey,
+            meta: {
+                scheduleType: types_1.ScheduleType.Custom,
+                timeZone: flow.schedule.timeZone,
+            },
+        };
+        delete result.schedule;
+    }
+    const actionStep = {
+        action: {
+            key: flowFunctionKey(flow.name, "action"),
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        },
+        name: "action",
+        errorConfig: "errorConfig" in flow.action ? flow.action.errorConfig : undefined,
+    };
+    result.steps = [triggerStep, actionStep];
+    return result;
+};
+/** Converts a Config Var into the structure necessary for YAML generation. */
+const convertConfigVar = (configVar, referenceKey) => {
+    const result = Object.assign(Object.assign({}, configVar), { meta: {} });
+    // Handle some non-standard fields.
+    if ("visibleToOrgDeployer" in result) {
+        result.meta.visibleToOrgDeployer = result.visibleToOrgDeployer;
+        delete result.visibleToOrgDeployer;
+    }
+    if ("visibleToCustomerDeployer" in result) {
+        result.meta.visibleToCustomerDeployer = result.visibleToCustomerDeployer;
+        delete result.visibleToCustomerDeployer;
+    }
+    if ("connection" in result && typeof result.connection === "string") {
+        result.connection = {
+            key: result.connection,
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        };
+    }
+    if ("dataSource" in result && typeof result.dataSource === "string") {
+        result.dataSource = {
+            key: result.dataSource,
+            component: { key: referenceKey, version: "LATEST", isPublic: false },
+        };
+    }
+    return result;
+};
+/** Maps the step name field to a fully qualified input. */
+const fieldNameToReferenceInput = (stepName, fieldName) => {
+    if (!fieldName) {
+        return undefined;
+    }
+    return {
+        type: types_1.SimpleInputValueType.Reference,
+        value: `${stepName}.results.${fieldName}`,
+    };
+};
+/** Actions and Triggers will be scoped to their flow by combining the flow
+ *  name and the function name. This is to ensure that the keys are unique
+ *  on the resulting object, which will be turned into a Component. */
+const flowFunctionKey = (flowName, functionName) => {
+    const flowKey = flowName
+        .replace(/[^0-9a-zA-Z]+/g, " ")
+        .trim()
+        .split(" ")
+        .map((w, i) => i === 0
+        ? w.toLowerCase()
+        : w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+        .join("");
+    // functionName is only going to be either 'action' or 'trigger'.
+    return `${flowKey}_${functionName}`;
+};
+/** Creates the structure necessary to import a Component as part of a
+ *  Code Native integration. */
+const codeNativeIntegrationComponent = ({ iconPath, description, flows = [], dataSources = {}, connections = [], }, referenceKey) => {
+    const convertedActions = flows.reduce((result, { name, action }) => {
+        const actionKey = flowFunctionKey(name, "action");
+        return Object.assign(Object.assign({}, result), { [actionKey]: convertAction(actionKey, Object.assign(Object.assign({}, action), { display: { label: "action", description: "" }, inputs: {} })) });
+    }, {});
+    const convertedTriggers = flows.reduce((result, { name, trigger }) => {
+        // Filter out TriggerReferences.
+        if (typeof trigger !== "object" || !("perform" in trigger))
+            return result;
+        const triggerKey = flowFunctionKey(name, "trigger");
+        return Object.assign(Object.assign({}, result), { [triggerKey]: convertTrigger(triggerKey, Object.assign(Object.assign({}, trigger), { display: { label: "trigger", description: "" }, inputs: {}, scheduleSupport: "valid", synchronousResponseSupport: "valid" })) });
+    }, {});
+    const convertedDataSources = Object.entries(dataSources).reduce((result, [dataSourceKey, dataSource]) => (Object.assign(Object.assign({}, result), { [dataSourceKey]: convertDataSource(dataSourceKey, Object.assign(Object.assign({}, dataSource), { inputs: {} })) })), {});
+    return {
+        key: referenceKey,
+        display: { label: referenceKey, iconPath, description: description || "" },
+        connections: connections.map(convertConnection),
+        actions: convertedActions,
+        triggers: convertedTriggers,
+        dataSources: convertedDataSources,
+    };
+};

package/dist/serverTypes/index.d.ts

@@ -1,14 +1,14 @@
 /// <reference types="node" />
-import { Instance, Customer, DataSourceType, DataSourceResultType, User, TriggerEventFunctionReturn, Integration, Flow } from "../types";
+import { InstanceAttributes, CustomerAttributes, DataSourceType, DataSourceResultType, UserAttributes, TriggerEventFunctionReturn, IntegrationAttributes, FlowAttributes } from "../types";
 interface DisplayDefinition {
     label: string;
     description: string;
 }
-export { Instance } from "../types";
-export { Customer } from "../types";
-export { User } from "../types";
-export { Integration } from "../types";
-export { Flow } from "../types";
+export { InstanceAttributes } from "../types";
+export { CustomerAttributes } from "../types";
+export { UserAttributes } from "../types";
+export { IntegrationAttributes } from "../types";
+export { FlowAttributes } from "../types";
 export interface Component {
     key: string;
     public?: boolean;
@@ -21,6 +21,7 @@ export interface Component {
     triggers: Record<string, Trigger>;
     dataSources: Record<string, DataSource>;
     connections: Connection[];
+    codeNativeIntegrationYAML?: string;
 }
 export interface Action {
     key: string;
@@ -58,11 +59,11 @@ export interface ActionContext {
     webhookUrls: Record<string, string>;
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
-    customer: Customer;
-    instance: Instance;
-    user: User;
-    integration: Integration;
-    flow: Flow;
+    customer: CustomerAttributes;
+    instance: InstanceAttributes;
+    user: UserAttributes;
+    integration: IntegrationAttributes;
+    flow: FlowAttributes;
     startedAt: string;
 }
 declare type TriggerOptionChoice = "invalid" | "valid" | "required";
@@ -82,11 +83,11 @@ export interface TriggerPayload {
     webhookApiKeys: Record<string, string[]>;
     invokeUrl: string;
     executionId: string;
-    customer: Customer;
-    instance: Instance;
-    user: User;
-    integration: Integration;
-    flow: Flow;
+    customer: CustomerAttributes;
+    instance: InstanceAttributes;
+    user: UserAttributes;
+    integration: IntegrationAttributes;
+    flow: FlowAttributes;
     startedAt: string;
 }
 interface HttpResponse {
@@ -136,9 +137,9 @@ export interface Trigger {
 }
 export interface DataSourceContext {
     logger: ActionLogger;
-    customer: Customer;
-    instance: Instance;
-    user: User;
+    customer: CustomerAttributes;
+    instance: InstanceAttributes;
+    user: UserAttributes;
 }
 export declare type DataSourceResult = {
     result: DataSourceResultType;

package/dist/types/ActionPerformFunction.d.ts

@@ -1,4 +1,4 @@
-import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger, Instance, Customer, User, Integration, Flow } from ".";
+import { Inputs, 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>;
 /** Context provided to perform method containing helpers and contextual data */
@@ -24,15 +24,15 @@ 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;
 }

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/{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,5 +1,5 @@
 /** Contains attributes of the Integration that is being executed. */
-export interface Integration {
+export interface IntegrationAttributes {
     id: string;
     name: string;
     versionSequenceId: string;

package/dist/types/IntegrationDefinition.d.ts

@@ -0,0 +1,298 @@
+import { DataSourceDefinition, ConnectionDefinition, ActionDefinition, ActionPerformReturn, TriggerDefinition, Inputs, TriggerResult, DataSourceType } from ".";
+/** Defines attributes of a Code-Native Integration. */
+export declare type IntegrationDefinition = {
+    /** 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. @default EndpointType.FlowSpecific. */
+    endpointType?: EndpointType;
+    /** Optional name of the Flow to use as a Preprocess Flow for 'Instance Specific' or 'Shared Instance' endpoint types. */
+    preprocessFlowName?: string;
+    /** Optional name of the field in the data payload returned by the Preprocess Flow to use for an External Customer Id,
+     *  or by the data payload returned by the Trigger if there is no Preprocess Flow specified. */
+    externalCustomerIdField?: string;
+    /** Optional name of the field in the data payload returned by the Preprocess Flow to use for an External Customer User Id,
+     *  or by the data payload returned by the Trigger if there is no Preprocess Flow specified. */
+    externalCustomerUserIdField?: string;
+    /** Optional name of the field in the data payload returned by the Preprocess Flow to use for a Flow Name,
+     *  or by the data payload returned by the Trigger if there is no Preprocess Flow specified. */
+    flowNameField?: string;
+    /** Flows for this Integration. */
+    flows: Flow[];
+    /** Config Vars used on this Integration. */
+    configVars?: ConfigVar[];
+    /** Config Wizard Pages for this Integration. */
+    configPages?: ConfigPage[];
+    /** Specifies any Data Sources that are defined as part of this Integration. */
+    dataSources?: Record<string, CodeNativeDataSource>;
+    /** Specifies any Connections that are defined as part of this Integration. */
+    connections?: ConnectionDefinition[];
+};
+/** Defines attributes of a Flow of a Code-Native Integration. */
+export declare type Flow = {
+    /** The unique name for this Flow. */
+    name: string;
+    /** Optional description for this Flow. */
+    description?: string;
+    /** 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;
+    /** Specifies the trigger for this Flow. */
+    trigger: (CodeNativeTrigger | TriggerReference) & {
+        /** Optional error handling configuration. */
+        errorConfig?: StepErrorConfig;
+    };
+    /** Specifies the main function for this Flow. */
+    action: CodeNativeAction;
+};
+/** Defines attributes of a Data Source that is defined as part of a Code Native Integration. */
+export declare type CodeNativeDataSource = Pick<DataSourceDefinition<Inputs, DataSourceType>, // TODO: Are these values correct?
+// TODO: Are these values correct?
+"display" | "perform" | "dataSourceType" | "detailDataSource">;
+/** Defines attributes of a Trigger that is defined as part of a Code Native Integration. */
+export declare type CodeNativeTrigger = Pick<TriggerDefinition<Inputs, false, TriggerResult<false>>, // TODO: Are these values correct?
+// TODO: Are these values correct?
+"perform" | "onInstanceDeploy" | "onInstanceDelete">;
+/** Defines attributes of an CodeNativeAction, which is the main function that will be executed for a Flow of a Code Native Integration. */
+export declare type CodeNativeAction = Pick<ActionDefinition<Inputs, false, ActionPerformReturn<false, unknown>>, // TODO: Are these values correct?
+"perform"> & {
+    /** Optional error handling configuration. */
+    errorConfig?: StepErrorConfig;
+};
+/** Defines attributes of a reference to an existing Trigger. */
+export declare type TriggerReference = {
+    /** Attributes of the referenced Component. */
+    component: ComponentReference;
+    /** The unique key that identifies the Trigger within the Component. */
+    key: string;
+    /** Optional input values for this Trigger. */
+    inputs?: InputValues;
+};
+/** Defines attributes of a reference to an existing Data Source. */
+export declare type DataSourceReference = {
+    /** Attributes of the referenced Component. */
+    component: ComponentReference;
+    /** The unique key that identifies the Data Source within the Component. */
+    key: string;
+};
+/** Defines attributes of a reference to an existing Connection. */
+export declare type ConnectionReference = {
+    /** Attributes of the referenced Component. */
+    component: ComponentReference;
+    /** The unique key that identifies the Connection within the Component. */
+    key: string;
+};
+/** Defines attributes of a reference to a member of an existing Component. */
+export declare type ComponentReference = {
+    /** The unique key that identifies the Component. */
+    key: string;
+    /** The version of the Component. */
+    version: number | "LATEST";
+    /** Specifies whether the Component is in the public library or a private Component. */
+    isPublic: boolean;
+};
+/** 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. */
+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 Data Source where the Config Var sources
+     *  its values. If it's a string then it's expected to be the key of a
+     *  CodeNativeDataSource defined in the Code Native Integration. Otherwise it
+     *  is expected to be a reference to an existing Data Source. */
+    dataSource?: string | DataSourceReference;
+};
+/** Defines attributes of a Config Var that represents a Connection. */
+declare type ConnectionConfigVar = BaseConfigVar & {
+    dataType: "connection";
+    /** Optional value to specify the Data Source where the Config Var sources
+     *  its values. If it's a string then it's expected to be the key of a
+     *  Connection defined in the Code Native Integration. Otherwise it is
+     *  expected to be a reference to an existing Connection. */
+    connection: string | ConnectionReference;
+};
+/** Defines attributes of a Config Var whose value is configured as part of deploying an Instance of an Integration. */
+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 = {
+    /** 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[];
+};
+/** 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 = {
+    /** Specifies what type of data is represented by this Element. */
+    type: ConfigPageElementType;
+    /** Specifies the value of this Element. */
+    value: 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/TriggerPayload.d.ts

@@ -1,4 +1,4 @@
-import { Instance, Customer, User, Integration, Flow } from ".";
+import { InstanceAttributes, CustomerAttributes, UserAttributes, IntegrationAttributes, FlowAttributes } from ".";
 /** Represents a Trigger Payload, which is data passed into a Trigger to invoke an Integration execution. */
 export interface TriggerPayload {
     headers: {
@@ -29,15 +29,15 @@ export interface TriggerPayload {
     invokeUrl: string;
     executionId: 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;
 }

package/dist/types/{User.d.ts → UserAttributes.d.ts}

@@ -1,5 +1,5 @@
 /** Contains attributes of the User for whom a User Level Configuration is being used. */
-export interface User {
+export interface UserAttributes {
     id: string;
     email: string;
     name: string;

package/dist/types/index.d.ts

@@ -22,9 +22,10 @@ export * from "./TriggerPayload";
 export * from "./DataSourceDefinition";
 export * from "./DataSourcePerformFunction";
 export * from "./DataSourceResult";
-export * from "./Instance";
-export * from "./Customer";
-export * from "./User";
-export * from "./Integration";
-export * from "./Flow";
+export * from "./InstanceAttributes";
+export * from "./CustomerAttributes";
+export * from "./UserAttributes";
+export * from "./IntegrationAttributes";
+export * from "./FlowAttributes";
+export * from "./IntegrationDefinition";
 export * as serverTypes from "../serverTypes";

package/dist/types/index.js

@@ -51,9 +51,10 @@ __exportStar(require("./TriggerPayload"), exports);
 __exportStar(require("./DataSourceDefinition"), exports);
 __exportStar(require("./DataSourcePerformFunction"), exports);
 __exportStar(require("./DataSourceResult"), exports);
-__exportStar(require("./Instance"), exports);
-__exportStar(require("./Customer"), exports);
-__exportStar(require("./User"), exports);
-__exportStar(require("./Integration"), exports);
-__exportStar(require("./Flow"), exports);
+__exportStar(require("./InstanceAttributes"), exports);
+__exportStar(require("./CustomerAttributes"), exports);
+__exportStar(require("./UserAttributes"), exports);
+__exportStar(require("./IntegrationAttributes"), exports);
+__exportStar(require("./FlowAttributes"), exports);
+__exportStar(require("./IntegrationDefinition"), exports);
 exports.serverTypes = __importStar(require("../serverTypes"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "7.8.4",
+  "version": "8.0.0-preview3",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"
@@ -48,7 +48,8 @@
     "soap": "1.0.0",
     "url-join": "5.0.0",
     "uuid": "8.3.2",
-    "valid-url": "1.0.9"
+    "valid-url": "1.0.9",
+    "yaml": "2.3.4"
   },
   "devDependencies": {
     "@types/jest": "27.4.1",