@prismatic-io/spectral 5.4.1 → 6.2.0

package/dist/serverTypes/index.d.ts

@@ -0,0 +1,178 @@
+/// <reference types="node" />
+interface DisplayDefinition {
+    label: string;
+    description: string;
+}
+export interface Component {
+    key: string;
+    public?: boolean;
+    documentationUrl?: string;
+    display: DisplayDefinition & {
+        category?: string;
+        iconPath?: string;
+    };
+    actions: Record<string, Action>;
+    triggers: Record<string, Trigger>;
+    connections: Connection[];
+}
+export 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;
+}
+export declare type ActionLoggerFunction = (...args: unknown[]) => void;
+export interface ActionLogger {
+    metric: ActionLoggerFunction;
+    trace: ActionLoggerFunction;
+    debug: ActionLoggerFunction;
+    info: ActionLoggerFunction;
+    log: ActionLoggerFunction;
+    warn: ActionLoggerFunction;
+    error: ActionLoggerFunction;
+}
+export 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";
+export 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;
+}
+export declare type TriggerResult = TriggerBranchingResult | TriggerBaseResult | undefined;
+export declare type TriggerPerformFunction = (context: ActionContext, payload: TriggerPayload, params: Record<string, unknown>) => Promise<TriggerResult>;
+export 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;
+}
+export declare enum OAuth2Type {
+    ClientCredentials = "client_credentials",
+    AuthorizationCode = "authorization_code"
+}
+export interface Connection {
+    key: string;
+    label: string;
+    comments?: string;
+    oauth2Type?: OAuth2Type;
+    iconPath?: string;
+    inputs: (Input & {
+        shown?: boolean;
+    })[];
+}
+export interface ConnectionValue {
+    key: string;
+    configVarKey: string;
+    fields: {
+        [key: string]: unknown;
+    };
+    token?: Record<string, unknown>;
+    context?: Record<string, unknown>;
+}
+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;
+}
+export declare type ActionPerformReturn = ServerPerformDataStructureReturn | ServerPerformBranchingDataStructureReturn | ServerPerformDataReturn | ServerPerformBranchingDataReturn | undefined;
+export declare type ActionPerformFunction = (context: ActionContext, params: Record<string, unknown>) => Promise<ActionPerformReturn>;
+interface InputFieldChoice {
+    label: string;
+    value: string;
+}
+export 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 {};

package/dist/serverTypes/index.js

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

package/dist/testing.d.ts

@@ -4,9 +4,9 @@
  * information on unit testing, check out our docs:
  * 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";
-export declare const createConnection: <T extends ConnectionDefinition>({ key }: T, values: Record<string, unknown>) => Connection;
+import { TriggerPayload, TriggerResult, Connection, ConnectionValue, ActionLogger, Component, ActionContext, ActionPerformReturn } from "./serverTypes";
+import { ConnectionDefinition, ActionDefinition, TriggerDefinition, Inputs, ActionInputParameters } from "./types";
+export declare const createConnection: <T extends Connection>({ key }: T, values: Record<string, unknown>) => ConnectionValue;
 /**
  * Pre-built mock of ActionLogger. Suitable for asserting logs are created as expected.
  * See https://prismatic.io/docs/custom-components/writing-custom-components/#verifying-correct-logging-in-action-tests for information on testing correct logging behavior in your custom component.
@@ -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,19 @@ 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>>>;
+export declare class ComponentTestHarness<TComponent extends Component> {
+    component: TComponent;
+    constructor(component: TComponent);
+    connectionValue({ key }: ConnectionDefinition): ConnectionValue;
+    trigger(key: string, payload?: TriggerPayload, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<TriggerResult>;
+    action(key: string, params?: Record<string, unknown>, context?: Partial<ActionContext>): Promise<ActionPerformReturn>;
+}
+export declare const createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 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>>;
     loggerMock: () => ActionLogger;
+    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>>>;
+    createHarness: <TComponent extends Component>(component: TComponent) => ComponentTestHarness<TComponent>;
 };
 export default _default;

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.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
+exports.createHarness = exports.ComponentTestHarness = exports.invokeTrigger = exports.defaultTriggerPayload = exports.invoke = exports.loggerMock = exports.createConnection = void 0;
 const jest_mock_1 = require("jest-mock");
 const createConnection = ({ key }, values) => ({
     configVarKey: "",
@@ -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,20 +94,52 @@ 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,
     };
 });
 exports.invokeTrigger = invokeTrigger;
+class ComponentTestHarness {
+    constructor(component) {
+        this.component = component;
+    }
+    connectionValue({ key }) {
+        const { PRISMATIC_CONNECTION_VALUE: value } = process.env;
+        if (!value) {
+            throw new Error("Unable to find connection value.");
+        }
+        const result = Object.assign(Object.assign({}, JSON.parse(value)), { key });
+        return result;
+    }
+    trigger(key, payload, params, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+            const trigger = this.component.triggers[key];
+            return trigger.perform(realizedContext, Object.assign(Object.assign({}, (0, exports.defaultTriggerPayload)()), payload), Object.assign({}, params));
+        });
+    }
+    action(key, params, context) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const realizedContext = Object.assign({ logger: (0, exports.loggerMock)(), instanceState: {}, crossFlowState: {}, executionState: {}, stepId: "mockStepId", executionId: "mockExecutionId" }, context);
+            const action = this.component.actions[key];
+            return action.perform(realizedContext, Object.assign({}, params));
+        });
+    }
+}
+exports.ComponentTestHarness = ComponentTestHarness;
+const createHarness = (component) => {
+    return new ComponentTestHarness(component);
+};
+exports.createHarness = createHarness;
 exports.default = {
+    loggerMock: exports.loggerMock,
     invoke: exports.invoke,
     invokeTrigger: exports.invokeTrigger,
-    loggerMock: exports.loggerMock,
+    createHarness: exports.createHarness,
 };

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,26 @@
-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;
+}
+/** Defines attributes of a Component. */
+export declare type ComponentDefinition<TPublic extends boolean> = {
+    /** 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;
+    /** 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;
+} & (TPublic extends true ? {
+    /** Specified the URL for the Component Documentation. */
+    documentationUrl: string;
+} : unknown);

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";