@prismatic-io/spectral 3.1.0

package/dist/types/ActionInputParameters.js

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

package/dist/types/ActionLogger.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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
+ */
+/**
+ * A logger function, similar to `console.log()` or `console.error()`.
+ */
+export declare type ActionLoggerFunction = (...args: unknown[]) => void;
+/**
+ * An object containing logger functions.
+ */
+export interface ActionLogger {
+    debug: ActionLoggerFunction;
+    info: ActionLoggerFunction;
+    log: ActionLoggerFunction;
+    warn: ActionLoggerFunction;
+    error: ActionLoggerFunction;
+}

package/dist/types/ActionLogger.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/ActionPerformFunction.d.ts

@@ -0,0 +1,14 @@
+import { Credential, Inputs, PerformReturn, 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 PerformReturn<AllowsBranching, unknown>> = (context: ActionContext, params: ActionInputParameters<T>) => Promise<ReturnData>;
+/** Context provided to perform method containing helpers and contextual data */
+export interface ActionContext {
+    /** Credential for the action, optional since not all actions will require a credential */
+    credential?: Credential;
+    /** 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 */
+    instanceState: Record<string, unknown>;
+    /** A unique id that corresponds to the step on the Integration */
+    stepId: string;
+}

package/dist/types/ActionPerformFunction.js

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

package/dist/types/AuthorizationDefinition.d.ts

@@ -0,0 +1,14 @@
+/** Authorization settings for a component */
+export interface AuthorizationDefinition {
+    /** Whether authorization is required */
+    required: boolean;
+    /** Supported authorization methods */
+    methods: AuthorizationMethod[];
+}
+declare const authorizationMethods: readonly ["basic", "api_key", "api_key_secret", "private_key", "oauth2", "oauth2_client_credentials"];
+export declare type AuthorizationMethod = typeof authorizationMethods[number];
+export declare const AvailableAuthorizationMethods: AuthorizationMethod[];
+declare const oauth2AuthorizationMethods: readonly ["oauth2", "oauth2_client_credentials"];
+export declare type OAuth2AuthorizationMethod = typeof oauth2AuthorizationMethods[number];
+export declare const AvailableOAuth2AuthorizationMethods: OAuth2AuthorizationMethod[];
+export {};

package/dist/types/AuthorizationDefinition.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailableOAuth2AuthorizationMethods = exports.AvailableAuthorizationMethods = void 0;
+const authorizationMethods = [
+    "basic",
+    "api_key",
+    "api_key_secret",
+    "private_key",
+    "oauth2",
+    "oauth2_client_credentials",
+];
+exports.AvailableAuthorizationMethods = [
+    ...authorizationMethods,
+];
+const oauth2AuthorizationMethods = [
+    "oauth2",
+    "oauth2_client_credentials",
+];
+exports.AvailableOAuth2AuthorizationMethods = [...oauth2AuthorizationMethods];

package/dist/types/Credential.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Types defined in this file describe the shape of credentials
+ * that can be passed to actions' perform functions.
+ * Read about the credential object at:
+ * https://prismatic.io/docs/custom-components/writing-custom-components#contextcredential
+ */
+/** */
+import { OAuth2AuthorizationMethod } from ".";
+export declare type Credential = BasicCredential | ApiKeyCredential | ApiKeySecretCredential | PrivateKeyCredential | OAuth2Credential;
+export interface BasicCredential {
+    authorizationMethod: "basic";
+    fields: {
+        username: string;
+        password: string;
+    };
+}
+export interface ApiKeyCredential {
+    authorizationMethod: "api_key";
+    fields: {
+        api_key: string;
+    };
+}
+export interface ApiKeySecretCredential {
+    authorizationMethod: "api_key_secret";
+    fields: {
+        api_key: string;
+        api_secret: string;
+    };
+}
+export interface PrivateKeyCredential {
+    authorizationMethod: "private_key";
+    fields: {
+        username: string;
+        private_key: string;
+    };
+}
+export interface OAuth2Credential {
+    authorizationMethod: OAuth2AuthorizationMethod;
+    redirectUri: string;
+    fields: {
+        client_id: string;
+        client_secret: string;
+        token_uri: string;
+        auth_uri?: string;
+        scopes?: string;
+        headers?: Record<string, string>;
+    };
+    token: {
+        access_token: string;
+        token_type: string;
+        refresh_token?: string;
+        expires_in?: string;
+        [key: string]: string | undefined;
+    };
+    context: {
+        [key: string]: string;
+    };
+}

package/dist/types/Credential.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Types defined in this file describe the shape of credentials
+ * that can be passed to actions' perform functions.
+ * Read about the credential object at:
+ * https://prismatic.io/docs/custom-components/writing-custom-components#contextcredential
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/DisplayDefinition.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Types in this file describe how an action or component should appear in the Prismatic web app.
+ */
+/** Base definition of Display properties. */
+interface DisplayDefinition {
+    /** Label/name to display. */
+    label: string;
+    /** Description to display to the user. */
+    description: string;
+}
+interface ExtraDisplayDefinitionFields {
+    /** Path to icon to use for this Component. Path should be relative to component roto index. */
+    iconPath?: string;
+    /** Category of the Component. */
+    category?: string;
+}
+/** Component extensions for display properties. */
+export declare type ComponentDisplayDefinition<T extends boolean> = T extends true ? DisplayDefinition & Required<ExtraDisplayDefinitionFields> : DisplayDefinition & ExtraDisplayDefinitionFields;
+/** Action-specific Display attributes. */
+export interface ActionDisplayDefinition extends DisplayDefinition {
+    /** Directions to help guide the user if additional configuration is required for this Action. */
+    directions?: string;
+    /** Indicate that this Action is important and/or commonly used from the parent Component. Should be enabled sparingly. */
+    important?: boolean;
+}
+export {};

package/dist/types/DisplayDefinition.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Types in this file describe how an action or component should appear in the Prismatic web app.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/InputFieldType.d.ts

@@ -0,0 +1,12 @@
+import { ConditionalExpression } from "./conditional-logic";
+/** InputField type enumeration. */
+export declare type InputFieldType = keyof InputFieldTypeMap;
+export declare type InputFieldTypeMap = {
+    string: unknown;
+    data: unknown;
+    text: unknown;
+    password: unknown;
+    boolean: unknown;
+    code: unknown;
+    conditional: ConditionalExpression;
+};

package/dist/types/InputFieldType.js

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

package/dist/types/Inputs.d.ts

@@ -0,0 +1,37 @@
+import { InputFieldType } from ".";
+export declare type Inputs = Record<string, InputFieldDefinition>;
+export declare type InputFieldDefinition = DefaultInputFieldDefinition | CodeInputFieldDefinition;
+/** Defines attributes of a InputField. */
+export interface DefaultInputFieldDefinition {
+    /** Interface label of the InputField. */
+    label: string;
+    /** Data type the InputField will collect. */
+    type: InputFieldType;
+    /** Collection type of the InputField */
+    collection?: InputFieldCollection;
+    /** Text to show as the InputField placeholder. */
+    placeholder?: string;
+    /** Default value for this field. */
+    default?: string;
+    /** Additional text to give guidance to the user configuring the InputField. */
+    comments?: string;
+    /** Example valid input for this InputField. */
+    example?: string;
+    /** Indicate if this InputField is required. */
+    required?: boolean;
+    /** Dictates possible choices for the input. */
+    model?: InputFieldChoice[];
+}
+export interface CodeInputFieldDefinition extends DefaultInputFieldDefinition {
+    type: "code";
+    language?: string;
+}
+/** Defines a single Choice option for a InputField. */
+export interface InputFieldChoice {
+    /** Label to display for this Choice. */
+    label: string;
+    /** Value to use if this Choice is chosen. */
+    value: string;
+}
+/** InputField collection enumeration */
+export declare type InputFieldCollection = "valuelist" | "keyvaluelist";

package/dist/types/Inputs.js

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

package/dist/types/PerformReturn.d.ts

@@ -0,0 +1,19 @@
+/** Used to represent a binary or serialized data return as content type must be specified */
+export interface PerformDataReturn<ReturnData> {
+    /** Data payload containing data of the specified contentType */
+    data: ReturnData;
+    /** The Content Type of the payload data */
+    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 */
+    state?: Record<string, unknown>;
+}
+/** Used to represent a branching return of conventional data and does not require content type to be specified */
+/** Used to represent a binary or serialized data branching return as content type must be specified */
+export interface PerformBranchingDataReturn<ReturnData> extends PerformDataReturn<ReturnData> {
+    /** Name of the Branch to take. */
+    branch: string;
+}
+/** Required return type of all action perform functions */
+export declare type PerformReturn<AllowsBranching extends boolean, ReturnData extends unknown> = (AllowsBranching extends true ? PerformBranchingDataReturn<ReturnData> : PerformDataReturn<ReturnData>) | void;

package/dist/types/PerformReturn.js

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

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

@@ -0,0 +1,91 @@
+/**
+ * This file contains types to help define conditional logic for the Prismatic
+ * branch component, https://prismatic.io/docs/components/branch
+ */
+/** @ignore */
+export declare enum BooleanOperator {
+    and = "and",
+    or = "or"
+}
+export declare const BooleanOperatorPhrase: string[];
+export declare enum UnaryOperator {
+    isTrue = "isTrue",
+    isFalse = "isFalse",
+    doesNotExist = "doesNotExist",
+    exists = "exists"
+}
+export declare const UnaryOperatorPhrase: {
+    isTrue: string;
+    isFalse: string;
+    doesNotExist: string;
+    exists: string;
+};
+export declare enum BinaryOperator {
+    equal = "equal",
+    notEqual = "notEqual",
+    greaterThan = "greaterThan",
+    greaterThanOrEqual = "greaterThanOrEqual",
+    lessThan = "lessThan",
+    lessThanOrEqual = "lessThanOrEqual",
+    in = "in",
+    notIn = "notIn",
+    exactlyMatches = "exactlyMatches",
+    doesNotExactlyMatch = "doesNotExactlyMatch",
+    startsWith = "startsWith",
+    doesNotStartWith = "doesNotStartWith",
+    endsWith = "endsWith",
+    doesNotEndWith = "doesNotEndWith",
+    dateTimeAfter = "dateTimeAfter",
+    dateTimeBefore = "dateTimeBefore",
+    dateTimeSame = "dateTimeSame"
+}
+export declare const BinaryOperatorPhrase: {
+    equal: string;
+    notEqual: string;
+    greaterThan: string;
+    greaterThanOrEqual: string;
+    lessThan: string;
+    lessThanOrEqual: string;
+    in: string;
+    notIn: string;
+    exactlyMatches: string;
+    doesNotExactlyMatch: string;
+    startsWith: string;
+    doesNotStartWith: string;
+    endsWith: string;
+    doesNotEndWith: string;
+    dateTimeAfter: string;
+    dateTimeBefore: string;
+    dateTimeSame: string;
+};
+export declare type TermOperator = UnaryOperator | BinaryOperator;
+export declare const TermOperatorPhrase: {
+    equal: string;
+    notEqual: string;
+    greaterThan: string;
+    greaterThanOrEqual: string;
+    lessThan: string;
+    lessThanOrEqual: string;
+    in: string;
+    notIn: string;
+    exactlyMatches: string;
+    doesNotExactlyMatch: string;
+    startsWith: string;
+    doesNotStartWith: string;
+    endsWith: string;
+    doesNotEndWith: string;
+    dateTimeAfter: string;
+    dateTimeBefore: string;
+    dateTimeSame: string;
+    isTrue: string;
+    isFalse: string;
+    doesNotExist: string;
+    exists: string;
+};
+export declare type Term = unknown;
+export declare type TermExpression = [TermOperator, Term, Term?];
+export declare type BooleanExpression = [
+    BooleanOperator.and | BooleanOperator.or,
+    ...ConditionalExpression[]
+];
+export declare type ConditionalExpression = TermExpression | BooleanExpression;

package/dist/types/conditional-logic.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * This file contains types to help define conditional logic for the Prismatic
+ * 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;
+/** @ignore */
+var BooleanOperator;
+(function (BooleanOperator) {
+    BooleanOperator["and"] = "and";
+    BooleanOperator["or"] = "or";
+})(BooleanOperator = exports.BooleanOperator || (exports.BooleanOperator = {}));
+exports.BooleanOperatorPhrase = Object.keys(BooleanOperator);
+var UnaryOperator;
+(function (UnaryOperator) {
+    UnaryOperator["isTrue"] = "isTrue";
+    UnaryOperator["isFalse"] = "isFalse";
+    UnaryOperator["doesNotExist"] = "doesNotExist";
+    UnaryOperator["exists"] = "exists";
+})(UnaryOperator = exports.UnaryOperator || (exports.UnaryOperator = {}));
+exports.UnaryOperatorPhrase = {
+    [UnaryOperator.isTrue]: "is true",
+    [UnaryOperator.isFalse]: "is false",
+    [UnaryOperator.doesNotExist]: "does not exist",
+    [UnaryOperator.exists]: "exists",
+};
+var BinaryOperator;
+(function (BinaryOperator) {
+    BinaryOperator["equal"] = "equal";
+    BinaryOperator["notEqual"] = "notEqual";
+    BinaryOperator["greaterThan"] = "greaterThan";
+    BinaryOperator["greaterThanOrEqual"] = "greaterThanOrEqual";
+    BinaryOperator["lessThan"] = "lessThan";
+    BinaryOperator["lessThanOrEqual"] = "lessThanOrEqual";
+    BinaryOperator["in"] = "in";
+    BinaryOperator["notIn"] = "notIn";
+    BinaryOperator["exactlyMatches"] = "exactlyMatches";
+    BinaryOperator["doesNotExactlyMatch"] = "doesNotExactlyMatch";
+    BinaryOperator["startsWith"] = "startsWith";
+    BinaryOperator["doesNotStartWith"] = "doesNotStartWith";
+    BinaryOperator["endsWith"] = "endsWith";
+    BinaryOperator["doesNotEndWith"] = "doesNotEndWith";
+    BinaryOperator["dateTimeAfter"] = "dateTimeAfter";
+    BinaryOperator["dateTimeBefore"] = "dateTimeBefore";
+    BinaryOperator["dateTimeSame"] = "dateTimeSame";
+})(BinaryOperator = exports.BinaryOperator || (exports.BinaryOperator = {}));
+exports.BinaryOperatorPhrase = {
+    [BinaryOperator.equal]: "equal",
+    [BinaryOperator.notEqual]: "does not equal",
+    [BinaryOperator.greaterThan]: "is greater than",
+    [BinaryOperator.greaterThanOrEqual]: "is greater than or equal to",
+    [BinaryOperator.lessThan]: "is less than",
+    [BinaryOperator.lessThanOrEqual]: "is less than or equal to",
+    [BinaryOperator.in]: "contained in",
+    [BinaryOperator.notIn]: "not contained in",
+    [BinaryOperator.exactlyMatches]: "exactly matches",
+    [BinaryOperator.doesNotExactlyMatch]: "does not exactly match",
+    [BinaryOperator.startsWith]: "starts with",
+    [BinaryOperator.doesNotStartWith]: "does not start with",
+    [BinaryOperator.endsWith]: "ends with",
+    [BinaryOperator.doesNotEndWith]: "does not end with",
+    [BinaryOperator.dateTimeAfter]: "is after (date/time)",
+    [BinaryOperator.dateTimeBefore]: "is before (date/time)",
+    [BinaryOperator.dateTimeSame]: "is the same (date/time)",
+};
+exports.TermOperatorPhrase = Object.assign(Object.assign({}, exports.UnaryOperatorPhrase), exports.BinaryOperatorPhrase);