@prismatic-io/spectral 5.4.1 → 6.1.0

package/dist/serverTypes/index.d.ts

@@ -0,0 +1,169 @@
+/// <reference types="node" />
+interface DisplayDefinition {
+    label: string;
+    description: string;
+}
+interface Component {
+    key: string;
+    public?: boolean;
+    documentationUrl?: string;
+    display: DisplayDefinition & {
+        category?: string;
+        iconPath?: string;
+    };
+    actions: Record<string, Action>;
+    triggers: Record<string, Trigger>;
+    connections: Connection[];
+}
+interface Action {
+    key: string;
+    display: DisplayDefinition & {
+        directions?: string;
+        important?: boolean;
+    };
+    inputs: Input[];
+    terminateExecution?: boolean;
+    breakLoop?: boolean;
+    allowsBranching?: boolean;
+    staticBranchNames?: string[];
+    dynamicBranchInput?: string;
+    perform: ActionPerformFunction;
+    examplePayload?: unknown;
+}
+declare type ActionLoggerFunction = (...args: unknown[]) => void;
+interface ActionLogger {
+    metric: ActionLoggerFunction;
+    trace: ActionLoggerFunction;
+    debug: ActionLoggerFunction;
+    info: ActionLoggerFunction;
+    log: ActionLoggerFunction;
+    warn: ActionLoggerFunction;
+    error: ActionLoggerFunction;
+}
+interface ActionContext {
+    logger: ActionLogger;
+    instanceState: Record<string, unknown>;
+    crossFlowState: Record<string, unknown>;
+    executionState: Record<string, unknown>;
+    stepId: string;
+    executionId: string;
+}
+declare type TriggerOptionChoice = "invalid" | "valid" | "required";
+interface TriggerPayload {
+    headers: Record<string, string>;
+    queryParameters: Record<string, string>;
+    rawBody: {
+        data: unknown;
+        contentType?: string;
+    };
+    body: {
+        data: unknown;
+        contentType?: string;
+    };
+    webhookUrls: Record<string, string>;
+    webhookApiKeys: Record<string, string[]>;
+    invokeUrl: string;
+    executionId: string;
+    customer: {
+        id: string | null;
+        externalId: string | null;
+        name: string | null;
+    };
+    instance: {
+        id: string | null;
+        name: string | null;
+    };
+}
+interface HttpResponse {
+    statusCode: number;
+    contentType: string;
+    headers?: Record<string, string>;
+    body?: string;
+}
+interface TriggerBaseResult {
+    payload: TriggerPayload;
+    response?: HttpResponse;
+    instanceState?: Record<string, unknown>;
+    crossFlowState?: Record<string, unknown>;
+    executionState?: Record<string, unknown>;
+}
+interface TriggerBranchingResult extends TriggerBaseResult {
+    branch: string;
+}
+declare type TriggerResult = TriggerBranchingResult | TriggerBaseResult | undefined;
+declare type TriggerPerformFunction = (context: ActionContext, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
+interface Trigger {
+    key: string;
+    display: DisplayDefinition & {
+        directions?: string;
+        important?: boolean;
+    };
+    inputs: Input[];
+    terminateExecution?: boolean;
+    breakLoop?: boolean;
+    allowsBranching?: boolean;
+    staticBranchNames?: string[];
+    dynamicBranchInput?: string;
+    perform: TriggerPerformFunction;
+    scheduleSupport: TriggerOptionChoice;
+    synchronousResponseSupport: TriggerOptionChoice;
+    examplePayload?: unknown;
+    isCommonTrigger?: boolean;
+}
+declare enum OAuth2Type {
+    ClientCredentials = "client_credentials",
+    AuthorizationCode = "authorization_code"
+}
+interface Connection {
+    key: string;
+    label: string;
+    comments?: string;
+    oauth2Type?: OAuth2Type;
+    iconPath?: string;
+    inputs: (Input & {
+        shown?: boolean;
+    })[];
+}
+interface ServerPerformDataStructureReturn {
+    data: boolean | number | string | Record<string, unknown> | unknown[] | unknown;
+    contentType?: string;
+    statusCode?: number;
+    instanceState?: Record<string, unknown>;
+    crossFlowState?: Record<string, unknown>;
+    executionState?: Record<string, unknown>;
+}
+interface ServerPerformDataReturn {
+    data: Buffer | string | unknown;
+    contentType: string;
+    statusCode?: number;
+    instanceState?: Record<string, unknown>;
+    crossFlowState?: Record<string, unknown>;
+    executionState?: Record<string, unknown>;
+}
+interface ServerPerformBranchingDataStructureReturn extends ServerPerformDataStructureReturn {
+    branch: string;
+}
+interface ServerPerformBranchingDataReturn extends ServerPerformDataReturn {
+    branch: string;
+}
+declare type ActionPerformReturn = ServerPerformDataStructureReturn | ServerPerformBranchingDataStructureReturn | ServerPerformDataReturn | ServerPerformBranchingDataReturn | undefined;
+declare type ActionPerformFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
+interface InputFieldChoice {
+    label: string;
+    value: string;
+}
+interface Input {
+    key: string;
+    label: string;
+    keyLabel?: string;
+    type: string;
+    collection?: string;
+    placeholder?: string;
+    default?: unknown;
+    comments?: string;
+    example?: string;
+    required?: boolean;
+    model?: InputFieldChoice[];
+    language?: string;
+}
+export type { Component, Trigger, Action, Connection, Input };

package/dist/serverTypes/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var OAuth2Type;
+(function (OAuth2Type) {
+    OAuth2Type["ClientCredentials"] = "client_credentials";
+    OAuth2Type["AuthorizationCode"] = "authorization_code";
+})(OAuth2Type || (OAuth2Type = {}));

package/dist/testing.d.ts

@@ -5,7 +5,7 @@
  * https://prismatic.io/docs/custom-components/writing-custom-components/#testing-a-component
  */
 /** */
-import { ActionContext, ActionLogger, ActionDefinition, ActionInputParameters, ConnectionDefinition, Connection, ActionPerformReturn, Inputs, TriggerDefinition, TriggerResult, TriggerPayload } from "./types";
+import { ActionContext, ActionLogger, ActionDefinition, ActionInputParameters, ConnectionDefinition, Connection, Inputs, TriggerDefinition, TriggerPayload } from "./types";
 export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>) => Connection;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
@@ -25,7 +25,7 @@ interface InvokeReturn<ReturnData> {
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * action result and a mock logger for asserting logging.
  */
-export declare const invoke: <T extends Inputs, AllowsBranching extends boolean, ReturnData extends ActionPerformReturn<AllowsBranching, unknown>>(actionBase: ActionDefinition<T, AllowsBranching, ReturnData> | Record<string, ActionDefinition<T, AllowsBranching, ReturnData>>, params: ActionInputParameters<T>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<ReturnData>>;
+export declare const invoke: <T extends Inputs>({ perform }: ActionDefinition<T>, params: ActionInputParameters<T>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<import("./types").ActionPerformReturn<boolean | undefined, unknown>>>;
 export declare const defaultTriggerPayload: () => TriggerPayload;
 /**
  * Invokes specified TriggerDefinition perform function using supplied params
@@ -33,10 +33,10 @@ export declare const defaultTriggerPayload: () => TriggerPayload;
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * trigger result and a mock logger for asserting logging.
  */
-export declare const invokeTrigger: <T extends Inputs, AllowsBranching extends boolean, Result extends TriggerResult<AllowsBranching>>(triggerBase: TriggerDefinition<T, AllowsBranching, Result> | Record<string, TriggerDefinition<T, AllowsBranching, Result>>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<T> | undefined) => Promise<InvokeReturn<Result>>;
+export declare const invokeTrigger: <T extends Inputs>({ perform }: TriggerDefinition<T>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<T> | undefined) => Promise<InvokeReturn<import("./types").TriggerResult<boolean | undefined>>>;
 declare const _default: {
-    invoke: <T extends Inputs, AllowsBranching extends boolean, ReturnData extends ActionPerformReturn<AllowsBranching, unknown>>(actionBase: ActionDefinition<T, AllowsBranching, ReturnData> | Record<string, ActionDefinition<T, AllowsBranching, ReturnData>>, params: ActionInputParameters<T>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<ReturnData>>;
-    invokeTrigger: <T_1 extends Inputs, AllowsBranching_1 extends boolean, Result extends TriggerResult<AllowsBranching_1>>(triggerBase: TriggerDefinition<T_1, AllowsBranching_1, Result> | Record<string, TriggerDefinition<T_1, AllowsBranching_1, Result>>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<T_1> | undefined) => Promise<InvokeReturn<Result>>;
+    invoke: <T extends Inputs>({ perform }: ActionDefinition<T>, params: ActionInputParameters<T>, context?: Partial<ActionContext> | undefined) => Promise<InvokeReturn<import("./types").ActionPerformReturn<boolean | undefined, unknown>>>;
+    invokeTrigger: <T_1 extends Inputs>({ perform }: TriggerDefinition<T_1>, context?: Partial<ActionContext> | undefined, payload?: TriggerPayload | undefined, params?: ActionInputParameters<T_1> | undefined) => Promise<InvokeReturn<import("./types").TriggerResult<boolean | undefined>>>;
     loggerMock: () => ActionLogger;
 };
 export default _default;

package/dist/testing.js

@@ -29,12 +29,12 @@ exports.createConnection = createConnection;
  */
 const loggerMock = () => ({
     metric: console.log,
-    trace: jest_mock_1.spyOn(console, "trace"),
-    debug: jest_mock_1.spyOn(console, "debug"),
-    info: jest_mock_1.spyOn(console, "info"),
-    log: jest_mock_1.spyOn(console, "log"),
-    warn: jest_mock_1.spyOn(console, "warn"),
-    error: jest_mock_1.spyOn(console, "error"),
+    trace: (0, jest_mock_1.spyOn)(console, "trace"),
+    debug: (0, jest_mock_1.spyOn)(console, "debug"),
+    info: (0, jest_mock_1.spyOn)(console, "info"),
+    log: (0, jest_mock_1.spyOn)(console, "log"),
+    warn: (0, jest_mock_1.spyOn)(console, "warn"),
+    error: (0, jest_mock_1.spyOn)(console, "error"),
 });
 exports.loggerMock = loggerMock;
 /**
@@ -43,10 +43,9 @@ exports.loggerMock = loggerMock;
  * to avoid extra casting within test methods. Returns an InvokeResult containing both the
  * action result and a mock logger for asserting logging.
  */
-const invoke = (actionBase, params, context) => __awaiter(void 0, void 0, void 0, function* () {
-    const action = (actionBase.perform ? actionBase : Object.values(actionBase)[0]);
-    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
-    const result = yield action.perform(realizedContext, params);
+const invoke = ({ perform }, params, context) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+    const result = yield perform(realizedContext, params);
     return {
         result,
         loggerMock: realizedContext.logger,
@@ -95,12 +94,11 @@ 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 = (triggerBase, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
-    const trigger = (triggerBase.perform ? triggerBase : Object.values(triggerBase)[0]);
-    const realizedContext = Object.assign({ logger: exports.loggerMock(), instanceState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
-    const realizedPayload = Object.assign(Object.assign({}, exports.defaultTriggerPayload()), payload);
+const invokeTrigger = ({ perform }, context, payload, params) => __awaiter(void 0, void 0, void 0, function* () {
+    const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+    const realizedPayload = Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload);
     const realizedParams = params || {};
-    const result = yield trigger.perform(realizedContext, realizedPayload, realizedParams);
+    const result = yield perform(realizedContext, realizedPayload, realizedParams);
     return {
         result,
         loggerMock: realizedContext.logger,

package/dist/types/ActionDefinition.d.ts

@@ -1,25 +1,25 @@
-import { ActionPerformReturn, ActionDisplayDefinition, ActionPerformFunction, Inputs } from ".";
+import { ActionDisplayDefinition, ActionPerformFunction, Inputs } from ".";
 /**
  * ActionDefinition is the type of the object that is passed in to `action` function to
  * define a component action.
  */
-export interface ActionDefinition<T extends Inputs, AllowsBranching extends boolean, ReturnData extends ActionPerformReturn<AllowsBranching, unknown>> {
+export interface ActionDefinition<TInputs extends Inputs> {
     /** Defines how the Action is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Action is invoked. */
-    perform: ActionPerformFunction<T, AllowsBranching, ReturnData>;
+    perform: ActionPerformFunction<this["inputs"], this["allowsBranching"]>;
     /** InputFields to present in the Prismatic interface for configuration of this Action. */
-    inputs: T;
+    inputs: TInputs;
     /** Optional attribute that specifies whether an Action will terminate execution.*/
     terminateExecution?: boolean;
     /** Specifies whether an Action will break out of a loop. */
     breakLoop?: boolean;
     /** Determines whether an Action will allow Conditional Branching.*/
-    allowsBranching?: AllowsBranching;
+    allowsBranching?: boolean;
     /** Static Branch names associated with an Action. */
     staticBranchNames?: string[];
     /** The Input associated with Dynamic Branching.*/
     dynamicBranchInput?: string;
     /** An example of the payload outputted by an Action*/
-    examplePayload?: ReturnData;
+    examplePayload?: Awaited<ReturnType<this["perform"]>>;
 }

package/dist/types/ActionInputParameters.d.ts

@@ -4,11 +4,11 @@ import { InputFieldDefinition, Inputs, InputFieldTypeMap } from ".";
  * Inputs can be static values, references to config variables, or
  * references to previous steps' outputs.
  */
-export declare type ActionInputParameters<TInputs extends Inputs> = TInputs extends Record<string, InputFieldDefinition> ? {
+export declare type ActionInputParameters<TInputs extends Inputs> = {
     [Property in keyof TInputs]: ExtractValue<TInputs[Property]>;
-} : never;
+};
 export declare type ExtractValue<TValue extends InputFieldDefinition> = MapCollectionValues<InputFieldTypeMap[TValue["type"]], TValue["collection"]>;
-export declare type MapCollectionValues<TType, TCollection extends InputFieldDefinition["collection"] | undefined> = TCollection extends "keyvaluelist" ? KeyValuePair<TType>[] | undefined : TCollection extends "valuelist" ? TType[] | undefined : TType;
+export declare type MapCollectionValues<TType, TCollection extends InputFieldDefinition["collection"]> = TCollection extends "keyvaluelist" ? KeyValuePair<TType>[] : TCollection extends "valuelist" ? TType[] : TType;
 /**
  * KeyValuePair input parameter type.
  * This allows users to input multiple keys / values as an input.

package/dist/types/ActionLogger.d.ts

@@ -2,7 +2,7 @@
  * Actions' perform functions receive a logger object as part of their first parameter.
  * Types in this file define the shape of the logger that is passed to an action.
  * For information on the logger object, see:
- * https://prismatic.io/docs/custom-components/writing-custom-components#contextlogger
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#contextlogger
  */
 /**
  * A logger function, similar to `console.log()` or `console.error()`.

package/dist/types/ActionLogger.js

@@ -3,6 +3,6 @@
  * Actions' perform functions receive a logger object as part of their first parameter.
  * Types in this file define the shape of the logger that is passed to an action.
  * For information on the logger object, see:
- * https://prismatic.io/docs/custom-components/writing-custom-components#contextlogger
+ * https://prismatic.io/docs/custom-components/writing-custom-components/#contextlogger
  */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ActionPerformFunction.d.ts

@@ -1,12 +1,14 @@
 import { Inputs, ActionPerformReturn, ActionInputParameters, ActionLogger } from ".";
 /** Definition of the function to perform when an Action is invoked. */
-export declare type ActionPerformFunction<T extends Inputs, AllowsBranching extends boolean, ReturnData extends ActionPerformReturn<AllowsBranching, unknown>> = (context: ActionContext, params: ActionInputParameters<T>) => Promise<ReturnData>;
+export declare type ActionPerformFunction<TInputs extends Inputs, AllowsBranching extends boolean | undefined> = (context: ActionContext, params: ActionInputParameters<TInputs>) => Promise<ActionPerformReturn<AllowsBranching, unknown>>;
 /** Context provided to perform method containing helpers and contextual data */
 export interface ActionContext {
     /** Logger for permanent logging; console calls are also captured */
     logger: ActionLogger;
-    /** A key/value store that may be used to store small amounts of data that is persisted between Instance executions */
+    /** A a flow-specific key/value store that may be used to store small amounts of data that is persisted between Instance executions */
     instanceState: Record<string, unknown>;
+    /** An key/value store what is shared between flows on an Instance that may be used to store small amounts of data that is persisted between Instance executions */
+    crossFlowState: Record<string, unknown>;
     /** A key/value store that may be used to store small amounts of data for use later during the execution */
     executionState: Record<string, unknown>;
     /** A unique id that corresponds to the step on the Integration */

package/dist/types/ActionPerformReturn.d.ts

@@ -6,8 +6,10 @@ export interface ActionPerformDataReturn<ReturnData> {
     contentType?: string;
     /** The HTTP Status code that will be used if this terminates a synchronous invocation  */
     statusCode?: number;
-    /** An optional object, the keys and values of which will be persisted in the instanceState and available for subsequent actions and executions */
+    /** 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>;
+    /** An optional object, the keys and values of which will be persisted in the crossFlowState and available in any flow for subsequent actions and executions */
+    crossFlowState: Record<string, unknown>;
     /** An optional object, the keys and values of which will be persisted in the executionState and available for the duration of the execution */
     executionState?: Record<string, unknown>;
 }
@@ -18,4 +20,4 @@ export interface ActionPerformBranchingDataReturn<ReturnData> extends ActionPerf
     branch: string;
 }
 /** Required return type of all action perform functions */
-export declare type ActionPerformReturn<AllowsBranching extends boolean, ReturnData> = (AllowsBranching extends true ? ActionPerformBranchingDataReturn<ReturnData> : ActionPerformDataReturn<ReturnData>) | undefined;
+export declare type ActionPerformReturn<AllowsBranching extends boolean | undefined, ReturnData> = (AllowsBranching extends true ? ActionPerformBranchingDataReturn<ReturnData> : ActionPerformDataReturn<ReturnData>) | undefined;

package/dist/types/ComponentDefinition.d.ts

@@ -1,7 +1,29 @@
-import { Component } from "./server-types";
-import { ActionPerformReturn, ActionDefinition, ConnectionDefinition, TriggerDefinition, TriggerResult } from ".";
-export declare type ComponentDefinition<T extends boolean> = Omit<Component<T>, "actions" | "triggers" | "connections"> & {
-    actions?: Record<string, ActionDefinition<any, boolean, ActionPerformReturn<boolean, any>>>;
-    triggers?: Record<string, TriggerDefinition<any, boolean, TriggerResult<boolean>>>;
+import { ActionDefinition, ConnectionDefinition, ComponentDisplayDefinition, TriggerDefinition } from ".";
+export declare type ErrorHandler = (error: unknown) => unknown;
+export interface ComponentHooks {
+    /** Defines a global error handler that automatically wraps the component's action/trigger perform functions. */
+    error?: ErrorHandler;
+}
+interface BaseComponentDefinition<TPublic extends boolean = false> {
+    /** Specifies unique key for this Component. */
+    key: string;
+    /** Specifies if this Component is available for all Organizations or only your own @default false */
+    public?: TPublic;
+    /** Specified the URL for the Component Documentation. */
+    documentationUrl?: string;
+    /** 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>>;
+    /** Specifies the supported Triggers of this Component. */
+    triggers?: Record<string, TriggerDefinition<any>>;
+    /** Specifies the supported Connections of this Component. */
     connections?: ConnectionDefinition[];
-};
+    /** Hooks */
+    hooks?: ComponentHooks;
+}
+/** Defines attributes of a Component. */
+export declare type ComponentDefinition<TPublic extends boolean = false> = BaseComponentDefinition<TPublic> & (TPublic extends true ? {
+    documentationUrl: string;
+} : unknown);
+export {};

package/dist/types/DataPayload.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/** Binary data payload */
+export interface DataPayload {
+    /** Raw binary data as a Buffer */
+    data: Buffer;
+    /** Content type of data contained within this payload */
+    contentType: string;
+    /** Suggested extension to use when writing the data */
+    suggestedExtension?: string;
+}

package/dist/types/DataPayload.js

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

package/dist/types/Inputs.d.ts

@@ -24,17 +24,20 @@ interface BaseInputFieldDefinition {
     example?: string;
     /** Indicate if this InputField is required. */
     required?: boolean;
-    /** Dictates possible choices for the input. */
-    model?: InputFieldChoice[];
 }
 /** Defines attributes of a InputField. */
 export interface DefaultInputFieldDefinition extends BaseInputFieldDefinition {
     type: Exclude<InputFieldType, "code" | "conditional" | "connection">;
+    /** Dictates possible choices for the input. */
+    model?: InputFieldChoice[];
 }
 /** Defines attributes of a CodeInputField. */
 export interface CodeInputFieldDefinition extends BaseInputFieldDefinition {
     type: Extract<InputFieldType, "code">;
+    /** Code language of this field. */
     language?: string;
+    /** Dictates possible choices for the input. */
+    model?: InputFieldChoice[];
 }
 /** Defines attributes of a ConditionalInputField. */
 export interface ConditionalInputField extends BaseInputFieldDefinition {

package/dist/types/TriggerDefinition.d.ts

@@ -1,4 +1,4 @@
-import { TriggerResult, ActionDisplayDefinition, TriggerPerformFunction, Inputs } from ".";
+import { ActionDisplayDefinition, TriggerPerformFunction, Inputs } from ".";
 declare const optionChoices: readonly ["invalid", "valid", "required"];
 export declare type TriggerOptionChoice = typeof optionChoices[number];
 export declare const TriggerOptionChoices: TriggerOptionChoice[];
@@ -6,13 +6,13 @@ 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<T extends Inputs, AllowsBranching extends boolean, Result extends TriggerResult<AllowsBranching>> {
+export interface TriggerDefinition<TInputs extends Inputs> {
     /** Defines how the Trigger is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Trigger is invoked. */
-    perform: TriggerPerformFunction<T, AllowsBranching, Result>;
+    perform: TriggerPerformFunction<this["inputs"], this["allowsBranching"]>;
     /** InputFields to present in the Prismatic interface for configuration of this Trigger. */
-    inputs: T;
+    inputs: TInputs;
     /** Specifies whether this Trigger supports executing the Integration on a recurring schedule. */
     scheduleSupport: TriggerOptionChoice;
     /** Specifies whether this Trigger supports synchronous responses to an Integration webhook request. */
@@ -22,13 +22,13 @@ export interface TriggerDefinition<T extends Inputs, AllowsBranching extends boo
     /** Specifies whether an Action will break out of a loop. */
     breakLoop?: boolean;
     /** Determines whether this Trigger allows Conditional Branching. */
-    allowsBranching?: AllowsBranching;
+    allowsBranching?: boolean;
     /** Static Branch names associated with this Trigger. */
     staticBranchNames?: string[];
     /** The Input associated with Dynamic Branching. */
     dynamicBranchInput?: string;
     /** An example of the payload outputted by this Trigger. */
-    examplePayload?: Result;
+    examplePayload?: Awaited<ReturnType<this["perform"]>>;
     /** Specifies if this Trigger appears in the list of 'common' Triggers. Only configurable by Prismatic. @default false */
     isCommonTrigger?: boolean;
 }

package/dist/types/TriggerPerformFunction.d.ts

@@ -1,3 +1,3 @@
 import { Inputs, TriggerResult, ActionInputParameters, ActionContext, TriggerPayload } from ".";
 /** Definition of the function to perform when a Trigger is invoked. */
-export declare type TriggerPerformFunction<T extends Inputs, AllowsBranching extends boolean, Result extends TriggerResult<AllowsBranching>> = (context: ActionContext, payload: TriggerPayload, params: ActionInputParameters<T>) => Promise<Result>;
+export declare type TriggerPerformFunction<T extends Inputs, AllowsBranching extends boolean | undefined> = (context: ActionContext, payload: TriggerPayload, params: ActionInputParameters<T>) => Promise<TriggerResult<AllowsBranching>>;

package/dist/types/TriggerResult.d.ts

@@ -2,12 +2,14 @@ import { TriggerPayload } from "./TriggerPayload";
 import { HttpResponse } from "./HttpResponse";
 /** Represents the result of a Trigger action. */
 export interface TriggerBaseResult {
-    /** The payload in the requst that invoked the Integration, which is returned as a result for later use. */
+    /** The payload in the request that invoked the Integration, which is returned as a result for later use. */
     payload: TriggerPayload;
     /** Optional HTTP response to the request that invoked the integration. */
     response?: HttpResponse;
-    /** An optional object, the keys and values of which will be persisted in the instanceState and available for subsequent actions and executions */
+    /** 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>;
+    /** An optional object, the keys and values of which will be persisted in the crossFlowState and available in any flow for subsequent actions and executions */
+    crossFlowState: Record<string, unknown>;
     /** An optional object, the keys and values of which will be persisted in the executionState and available for the duration of the execution */
     executionState?: Record<string, unknown>;
 }
@@ -17,4 +19,4 @@ export interface TriggerBranchingResult extends TriggerBaseResult {
     branch: string;
 }
 /** Required return type of all trigger perform functions */
-export declare type TriggerResult<AllowsBranching extends boolean> = (AllowsBranching extends true ? TriggerBranchingResult : TriggerBaseResult) | undefined;
+export declare type TriggerResult<AllowsBranching extends boolean | undefined> = (AllowsBranching extends true ? TriggerBranchingResult : TriggerBaseResult) | undefined;

package/dist/types/conditional-logic.d.ts

@@ -1,6 +1,6 @@
 /**
  * This file contains types to help define conditional logic for the Prismatic
- * branch component, https://prismatic.io/docs/components/branch
+ * branch component, https://prismatic.io/docs/components/branch/
  */
 /** @ignore */
 export declare enum BooleanOperator {

package/dist/types/conditional-logic.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * This file contains types to help define conditional logic for the Prismatic
- * branch component, https://prismatic.io/docs/components/branch
+ * branch component, https://prismatic.io/docs/components/branch/
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TermOperatorPhrase = exports.BinaryOperatorPhrase = exports.BinaryOperator = exports.UnaryOperatorPhrase = exports.UnaryOperator = exports.BooleanOperatorPhrase = exports.BooleanOperator = void 0;

package/dist/types/index.d.ts

@@ -7,6 +7,7 @@ export * from "./ComponentDefinition";
 export * from "./ConnectionDefinition";
 export * from "./Inputs";
 export * from "./ActionPerformReturn";
+export * from "./DataPayload";
 export * from "./DisplayDefinition";
 export * from "./ActionInputParameters";
 export * from "./ActionLogger";
@@ -18,4 +19,3 @@ export * from "./TriggerPerformFunction";
 export * from "./TriggerDefinition";
 export * from "./HttpResponse";
 export * from "./TriggerPayload";
-export * as serverTypes from "./server-types";

package/dist/types/index.js

@@ -5,33 +5,25 @@
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
 }));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serverTypes = void 0;
 __exportStar(require("./ActionDefinition"), exports);
 __exportStar(require("./ComponentDefinition"), exports);
 __exportStar(require("./ConnectionDefinition"), exports);
 __exportStar(require("./Inputs"), exports);
 __exportStar(require("./ActionPerformReturn"), exports);
+__exportStar(require("./DataPayload"), exports);
 __exportStar(require("./DisplayDefinition"), exports);
 __exportStar(require("./ActionInputParameters"), exports);
 __exportStar(require("./ActionLogger"), exports);
@@ -43,4 +35,3 @@ __exportStar(require("./TriggerPerformFunction"), exports);
 __exportStar(require("./TriggerDefinition"), exports);
 __exportStar(require("./HttpResponse"), exports);
 __exportStar(require("./TriggerPayload"), exports);
-exports.serverTypes = __importStar(require("./server-types"));

package/dist/util.d.ts

@@ -3,8 +3,13 @@
  * Many functions in the `util` module are used to coerce data into a particular type, and can be accessed through `util.types`.
  * For example, `util.types.toInt("5.5")` will return an integer, `5`.
  */
-import { DataPayload } from "./types/server-types";
-import { KeyValuePair } from "./types";
+import { KeyValuePair, DataPayload } from "./types";
+/** This function accepts an arbitrary object/value and safely serializes it (handles cyclic references).
+ *
+ * @param value Arbitrary object/value to serialize.
+ * @returns JSON serialized text that can be safely logged.
+ */
+export declare const toJSON: (value: unknown) => string;
 /**
  * This function returns a lower cased version of the headers passed to it.
  *
@@ -33,8 +38,9 @@ declare const _default: {
         isData: (value: unknown) => boolean;
         toData: (value: unknown) => DataPayload;
         toString: (value: unknown, defaultValue?: string) => string;
-        keyValPairListToObject: (kvpList?: KeyValuePair<unknown>[]) => Record<string, unknown>;
+        keyValPairListToObject: <TValue = unknown>(kvpList?: KeyValuePair<unknown>[], valueConverter?: ((value: unknown) => TValue) | undefined) => Record<string, TValue>;
         isJSON: (value: string) => boolean;
+        toJSON: (value: unknown) => string;
         lowerCaseHeaders: (headers: Record<string, string>) => Record<string, string>;
     };
     docs: {