@prismatic-io/spectral 8.0.0-preview8 → 8.0.0

package/dist/types/Inputs.d.ts

@@ -1,5 +1,18 @@
 import { ConditionalExpression } from "./conditional-logic";
 import { JsonSchema, UISchemaElement } from "@jsonforms/core";
+/**
+ * KeyValuePair input parameter type.
+ * This allows users to input multiple keys / values as an input.
+ * To see an example of how this can be used, see the `tagging` input
+ * of the `putObject` action of the AWS S3 component:
+ * https://github.com/prismatic-io/examples/blob/main/components/aws-s3/src/actions.ts
+ */
+export interface KeyValuePair<V = unknown> {
+    /** Key of the KeyValuePair */
+    key: string;
+    /** Value of the KeyValuePair */
+    value: V;
+}
 export declare type Element = {
     key: string;
     label?: string;
@@ -66,81 +79,76 @@ interface BaseInputField {
     /** Indicate if this InputField is required. */
     required?: boolean;
 }
-export interface StringInputField extends BaseInputField {
-    /** Data type the InputField will collect. */
-    type: "string";
+declare type CollectionOptions<T> = SingleValue<T> | ValueListCollection<T> | KeyValueListCollection<T>;
+interface SingleValue<T> {
     /** Collection type of the InputField */
-    collection?: InputFieldCollection;
+    collection?: undefined;
     /** Default value for this field. */
-    default?: unknown;
+    default?: T;
+}
+interface ValueListCollection<T> {
+    /** Collection type of the InputField */
+    collection: "valuelist";
+    /** Default value for this field. */
+    default?: T[];
+}
+interface KeyValueListCollection<T> {
+    /** Collection type of the InputField */
+    collection: "keyvaluelist";
+    /** Default value for this field. */
+    default?: KeyValuePair<T>[];
+}
+export declare type StringInputField = BaseInputField & CollectionOptions<string> & {
+    /** Data type the InputField will collect. */
+    type: "string";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface DataInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type DataInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "data";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface TextInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type TextInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "text";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface PasswordInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type PasswordInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "password";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
-export interface BooleanInputField extends BaseInputField {
+    clean?: InputCleanFunction<unknown>;
+};
+export declare type BooleanInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "boolean";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
+    clean?: InputCleanFunction<unknown>;
+};
 /** Defines attributes of a CodeInputField. */
-export interface CodeInputField extends BaseInputField {
+export declare type CodeInputField = BaseInputField & CollectionOptions<string> & {
     /** Data type the InputField will collect. */
     type: "code";
-    /** Collection type of the InputField */
-    collection?: InputFieldCollection;
-    /** Default value for this field. */
-    default?: unknown;
     /** Code language for syntax highlighting. For no syntax highlighting, choose "plaintext" */
     language: "css" | "graphql" | "handlebars" | "hcl" | "html" | "javascript" | "json" | "liquid" | "markdown" | "mysql" | "pgsql" | "plaintext" | "sql" | "typescript" | "xml" | "yaml";
     /** Dictates possible choices for the input. */
     model?: InputFieldChoice[];
     /** Clean function */
-    clean?: InputCleanFunction<this["default"]>;
-}
+    clean?: InputCleanFunction<unknown>;
+};
 /** Defines attributes of a ConditionalInputField. */
 export interface ConditionalInputField extends BaseInputField {
     /** Data type the InputField will collect. */
@@ -239,4 +247,6 @@ export interface InputFieldChoice {
 }
 /** InputField collection enumeration */
 export declare type InputFieldCollection = "valuelist" | "keyvaluelist";
+/** Config variable result collection */
+export declare type ConfigVarResultCollection = Record<string, string | Connection | JSONForm | ObjectSelection>;
 export {};

package/dist/types/IntegrationDefinition.d.ts

@@ -1,6 +1,10 @@
-import { DataSourceDefinition, ConnectionDefinition, ActionPerformFunction, ActionPerformReturn, TriggerEventFunction, TriggerPerformFunction, Inputs, TriggerResult, DataSourceType } from ".";
+import { DataSourceDefinition, ConnectionDefinition, ActionPerformFunction, ActionPerformReturn, TriggerEventFunction, TriggerPerformFunction, Inputs, TriggerResult, DataSourceType, Connection as ConnectionResult, TriggerPayload } from ".";
+export declare type ConfigVarCollection = Record<string, ConfigVar>;
+export declare type ConfigVarDefinitionsToResults<TConfigVars extends ConfigVarCollection> = {
+    [Key in keyof TConfigVars]: TConfigVars[Key]["inputs"] extends Record<string, any> ? ConnectionResult : string;
+};
 /** Defines attributes of a Code-Native Integration. */
-export declare type IntegrationDefinition = {
+export declare type IntegrationDefinition<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = {
     /** The unique name for this Integration. */
     name: string;
     /** Optional description for this Integration. */
@@ -23,18 +27,20 @@ export declare type IntegrationDefinition = {
      *  Cannot specify this if a Preprocess Flow is also configured. */
     triggerPreprocessFlowConfig?: PreprocessFlowConfig;
     /** Flows for this Integration. */
-    flows: Flow[];
+    flows: Flow<TConfigVars>[];
     /** Config Vars used on this Integration. */
-    configVars?: ConfigVar[];
+    configVars?: TConfigVars;
     /** Config Wizard Pages for this Integration. */
-    configPages?: ConfigPage[];
+    configPages?: ConfigPage<TConfigVars>[];
     /** Specifies any Data Sources that are defined as part of this Integration. */
     dataSources?: Record<string, CodeNativeDataSource>;
 };
-/** Defines common attributes of a Flow of a Code-Native Integration. */
-declare type BaseFlow = {
+/** Defines attributes of a Flow of a Code-Native Integration. */
+export interface Flow<TConfigVars extends ConfigVarCollection = ConfigVarCollection, TTriggerPayload extends TriggerPayload = TriggerPayload> {
     /** The unique name for this Flow. */
     name: string;
+    /** A unique, unchanging value that is used to maintain identity for the Flow even if the name changes. */
+    stableKey: string;
     /** Optional description for this Flow. */
     description?: string;
     /** Optional Preprocess Flow configuration for when the result of this Flow contains the flow routing attributes. Only one Flow per Integration may define this. */
@@ -51,56 +57,31 @@ declare type BaseFlow = {
     schedule?: FlowSchedule;
     /** Optional error handling configuration. */
     errorConfig?: StepErrorConfig;
-    /** Specifies the main function for this Flow */
-    onExecution: ActionPerformFunction<Inputs, false, ActionPerformReturn<false, unknown>>;
-};
-/** Defines attributes of a Flow that will have custom Trigger logic. */
-declare type CustomTriggerFlow = BaseFlow & {
     /** Specifies the trigger function for this Flow, which returns a payload and optional HTTP response. */
-    onTrigger: TriggerPerformFunction<Inputs, false, TriggerResult<false>>;
+    onTrigger: TriggerPerformFunction<Inputs, ConfigVarDefinitionsToResults<TConfigVars>, true, false, TriggerResult<false, TTriggerPayload>>;
     /** Specifies the function to execute when an Instance of this Integration is deployed. */
-    onInstanceDeploy?: TriggerEventFunction<Inputs>;
+    onInstanceDeploy?: TriggerEventFunction<Inputs, ConfigVarDefinitionsToResults<TConfigVars>, true>;
     /** Specifies the function to execute when an Instance of an Integration is deleted. */
-    onInstanceDelete?: TriggerEventFunction<Inputs>;
-};
-/** Defines attributes of a Flow that will use a Trigger from an existing Component. */
-declare type PrebuiltTriggerFlow = BaseFlow & {
-    /** Specifies the prebuilt Trigger that will run when this Flow executes. */
-    trigger: TriggerReference;
-};
-/** Defines attributes of a Flow of a Code-Native Integration. */
-export declare type Flow = CustomTriggerFlow | PrebuiltTriggerFlow;
+    onInstanceDelete?: TriggerEventFunction<Inputs, ConfigVarDefinitionsToResults<TConfigVars>, true>;
+    /** Specifies the main function for this Flow */
+    onExecution: ActionPerformFunction<{
+        onTrigger: {
+            type: "data";
+            label: string;
+            clean: (value: unknown) => {
+                results: TTriggerPayload;
+            };
+        };
+    }, ConfigVarDefinitionsToResults<TConfigVars>, true, false, ActionPerformReturn<false, unknown>>;
+}
 /** Defines attributes of a Data Source that is defined as part of a Code Native Integration. */
 export declare type CodeNativeDataSource = Pick<DataSourceDefinition<Inputs, DataSourceType>, "display" | "perform" | "dataSourceType" | "detailDataSource">;
-/** 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 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;
+    /** A unique, unchanging value that is used to maintain identity for the Config Var even if the key changes. */
+    stableKey: 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  */
@@ -128,21 +109,15 @@ export declare type StandardConfigVar = BaseConfigVar & {
     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;
+    /** Optional value to specify the key of a Data Source defined in this CNI
+     *  where the Config Var sources its values. */
+    dataSource?: string;
 };
 /** Defines attributes of a Config Var that represents a Connection. */
 export declare type ConnectionConfigVar = Omit<BaseConfigVar, "description" | "inputs"> & ConnectionDefinition;
-export declare type ConnectionRefConfigVar = BaseConfigVar & {
-    /** Attributes of the referenced Component. */
-    component: ComponentReference;
-};
-export declare type ConfigVar = StandardConfigVar | ConnectionConfigVar | ConnectionRefConfigVar;
+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 = {
+export declare type ConfigPage<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = {
     /** The unique name for this Config Page. */
     name: string;
     /** Specifies an optional tagline for this Config Page. */
@@ -151,7 +126,7 @@ export declare type ConfigPage = {
      *  part of User Level Configuration. @default false */
     userLevelConfigured?: boolean;
     /** Elements included on this Config Page. */
-    elements: ConfigPageElement[];
+    elements: ConfigPageElement<TConfigVars>[];
 };
 /** Defines attributes of Inputs for Connections, Actions, Triggers,
  *  Data Sources, and Config Vars. */
@@ -171,12 +146,19 @@ export declare type ComplexInputValue = {
 };
 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. */
+export declare type ConfigPageElement<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = HTMLConfigPageElement | JSONFormConfigPageElement | ConfigVarPageElement<TConfigVars>;
+declare type HTMLConfigPageElement = {
+    type: ConfigPageElementType.HTML;
     value: string;
 };
+declare type JSONFormConfigPageElement = {
+    type: ConfigPageElementType.JSONForm;
+    value: string;
+};
+declare type ConfigVarPageElement<TConfigVars extends ConfigVarCollection = ConfigVarCollection> = {
+    type: ConfigPageElementType.ConfigVar;
+    value: keyof TConfigVars;
+};
 /** Defines attributes of a Preprocess Flow Configuration used by a Flow of an Integration. */
 export declare type PreprocessFlowConfig = {
     /** Name of the field in the data payload returned by the Preprocess Flow to use for a Flow Name. */

package/dist/types/TriggerDefinition.d.ts

@@ -1,4 +1,4 @@
-import { ActionDisplayDefinition, TriggerPerformFunction, TriggerEventFunction, Inputs, TriggerResult } from ".";
+import { ActionDisplayDefinition, TriggerPerformFunction, TriggerEventFunction, Inputs, TriggerResult, ConfigVarResultCollection, TriggerPayload } from ".";
 declare const optionChoices: readonly ["invalid", "valid", "required"];
 export declare type TriggerOptionChoice = typeof optionChoices[number];
 export declare const TriggerOptionChoices: TriggerOptionChoice[];
@@ -6,15 +6,15 @@ 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<TInputs extends Inputs, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching>> {
+export interface TriggerDefinition<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, TAllowsBranching extends boolean, TResult extends TriggerResult<TAllowsBranching, TriggerPayload>> {
     /** Defines how the Trigger is displayed in the Prismatic interface. */
     display: ActionDisplayDefinition;
     /** Function to perform when this Trigger is invoked. */
-    perform: TriggerPerformFunction<TInputs, TAllowsBranching, TResult>;
+    perform: TriggerPerformFunction<TInputs, TConfigVars, false, TAllowsBranching, TResult>;
     /** Function to execute when an Instance of an Integration with a Flow that uses this Trigger is deployed. */
-    onInstanceDeploy?: TriggerEventFunction<TInputs>;
+    onInstanceDeploy?: TriggerEventFunction<TInputs, TConfigVars, false>;
     /** Function to execute when an Instance of an Integration with a Flow that uses this Trigger is deleted. */
-    onInstanceDelete?: TriggerEventFunction<TInputs>;
+    onInstanceDelete?: TriggerEventFunction<TInputs, TConfigVars, false>;
     /** InputFields to present in the Prismatic interface for configuration of this Trigger. */
     inputs: TInputs;
     /** Specifies whether this Trigger supports executing the Integration on a recurring schedule. */

package/dist/types/TriggerEventFunction.d.ts

@@ -1,4 +1,4 @@
-import { Inputs, ActionContext, ActionInputParameters } from ".";
+import { Inputs, ActionContext, ActionInputParameters, ConfigVarResultCollection } from ".";
 export declare type TriggerEventFunctionReturn = {
     /** 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>;
@@ -10,4 +10,4 @@ export declare type TriggerEventFunctionReturn = {
     integrationState?: Record<string, unknown>;
 };
 /** Definition of the function to execute when a Trigger Event occurs. */
-export declare type TriggerEventFunction<TInputs extends Inputs> = (context: ActionContext, params: ActionInputParameters<TInputs>) => Promise<void | TriggerEventFunctionReturn>;
+export declare type TriggerEventFunction<TInputs extends Inputs, TConfigVars extends ConfigVarResultCollection, THasConfigVars extends boolean> = (context: ActionContext<TConfigVars, THasConfigVars>, params: ActionInputParameters<TInputs>) => Promise<void | TriggerEventFunctionReturn>;

package/dist/types/TriggerPerformFunction.d.ts

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

package/dist/types/TriggerResult.d.ts

@@ -1,9 +1,9 @@
 import { TriggerPayload } from "./TriggerPayload";
 import { HttpResponse } from "./HttpResponse";
 /** Represents the result of a Trigger action. */
-export interface TriggerBaseResult {
+export interface TriggerBaseResult<TPayload extends TriggerPayload> {
     /** The payload in the request that invoked the Integration, which is returned as a result for later use. */
-    payload: TriggerPayload;
+    payload: TPayload;
     /** 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 flow-specific instanceState and available for subsequent actions and executions */
@@ -20,9 +20,9 @@ export interface TriggerBaseResult {
     error?: Record<string, unknown>;
 }
 /** Represents the result of a Trigger action that uses branching. */
-export interface TriggerBranchingResult extends TriggerBaseResult {
+export interface TriggerBranchingResult<TPayload extends TriggerPayload> extends TriggerBaseResult<TPayload> {
     /** Name of the Branch to take. */
     branch: string;
 }
 /** Required return type of all trigger perform functions */
-export declare type TriggerResult<AllowsBranching extends boolean | undefined> = (AllowsBranching extends true ? TriggerBranchingResult : TriggerBaseResult) | undefined;
+export declare type TriggerResult<AllowsBranching extends boolean | undefined, TPayload extends TriggerPayload> = (AllowsBranching extends true ? TriggerBranchingResult<TPayload> : TriggerBaseResult<TPayload>) | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prismatic-io/spectral",
-  "version": "8.0.0-preview8",
+  "version": "8.0.0",
   "description": "Utility library for building Prismatic components",
   "keywords": [
     "prismatic"
@@ -38,14 +38,13 @@
   ],
   "dependencies": {
     "@jsonforms/core": "3.0.0",
-    "axios": "0.27.2",
-    "axios-retry": "3.2.5",
+    "axios": "1.6.2",
+    "axios-retry": "3.9.1",
     "date-fns": "2.30.0",
     "form-data": "4.0.0",
     "jest-mock": "27.0.3",
     "safe-stable-stringify": "2.3.1",
     "serialize-error": "8.1.0",
-    "soap": "1.0.0",
     "url-join": "5.0.0",
     "uuid": "8.3.2",
     "valid-url": "1.0.9",

package/dist/clients/soap/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./types";
-export * from "./utils";

package/dist/clients/soap/index.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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 __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);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./utils"), exports);

package/dist/clients/soap/types.d.ts

@@ -1,71 +0,0 @@
-import { Connection } from "../../index";
-import { IMTOMAttachments } from "soap";
-/**
- * SOAPConnection takes standard connection fields, and adds an optional `wsdlDefinitionUrl` field.
- */
-export interface SOAPConnection extends Connection {
-    fields: {
-        [key: string]: unknown;
-        wsdlDefinitionUrl?: string;
-    };
-}
-/**
- * This function determines if the object presented is a SOAP connection with a `wsdlDefinitionUrl` field.
- * @param connection The connection to test
- * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
- */
-export declare const isSOAPConnection: (connection: unknown) => connection is SOAPConnection;
-/**
- * SOAP requests return a 4-tuple or 5-tuple with the response first, the XML response second, headers third, and the XML request fourth, and optional message attachments fifth.
- */
-export declare type SOAPResponse = [any, any, any, any, IMTOMAttachments?];
-/**
- * Overload the `soapRequest` function to take a variety of types of arguments.
- */
-export interface SOAPRequest {
-    (params: RequestParams): Promise<SOAPResponse>;
-    (params: RequestParams, methodParams: Record<string, unknown>): Promise<SOAPResponse>;
-    (params: RequestParams, methodParams: undefined): Promise<SOAPResponse>;
-}
-export interface RequestParams {
-    wsdlParam: SOAPConnection | string;
-    method: string;
-    overrides?: ClientOverrides;
-    debug?: boolean;
-}
-export interface ClientOverrides {
-    endpointURL?: string;
-    soapHeaders?: unknown[];
-}
-export interface HeaderPayload {
-    [x: string]: any;
-}
-export interface GenerateHeader {
-    (wsdlParam: SOAPConnection | string, headerPayload: HeaderPayload, headerOptions: undefined): Promise<string>;
-    (wsdlParam: SOAPConnection | string, headerPayload: HeaderPayload, headerOptions: {
-        namespace: string;
-        xmlns: string;
-    }): Promise<string>;
-}
-export interface BasicAuthConnection extends Connection {
-    fields: {
-        [key: string]: unknown;
-        username: unknown;
-        password: unknown;
-        loginMethod: unknown;
-    };
-}
-/**
- * This function determines if the object presented is a Basic Auth connection with `username`, `password`, and `loginMethod` fields.
- * @param connection The connection to test
- * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
- */
-export declare const isBasicAuthConnection: (connection: Connection) => connection is BasicAuthConnection;
-export interface SOAPAuth {
-    (connection: BasicAuthConnection, wsdlDefinition: string): Promise<any>;
-    (connection: BasicAuthConnection & SOAPConnection): Promise<any>;
-}
-export interface DescribeWSDL {
-    (connection: SOAPConnection): Promise<any>;
-    (wsdlDefinition: string): Promise<any>;
-}

package/dist/clients/soap/types.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isBasicAuthConnection = exports.isSOAPConnection = void 0;
-/**
- * This function determines if the object presented is a SOAP connection with a `wsdlDefinitionUrl` field.
- * @param connection The connection to test
- * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
- */
-const isSOAPConnection = (connection) => {
-    if (typeof connection === "object" && connection !== null)
-        return "wsdlDefinitionURL" in (connection === null || connection === void 0 ? void 0 : connection.fields);
-    return false;
-};
-exports.isSOAPConnection = isSOAPConnection;
-/**
- * This function determines if the object presented is a Basic Auth connection with `username`, `password`, and `loginMethod` fields.
- * @param connection The connection to test
- * @returns This function returns true if the connection is a SOAPConnection, and false otherwise.
- */
-const isBasicAuthConnection = (connection) => {
-    const { fields } = connection;
-    return ("username" in fields && "password" in fields && "loginMethod" in fields);
-};
-exports.isBasicAuthConnection = isBasicAuthConnection;

package/dist/clients/soap/utils.d.ts

@@ -1,12 +0,0 @@
-import { ClientOverrides, GenerateHeader, SOAPAuth, SOAPConnection, SOAPRequest, DescribeWSDL } from "./types";
-import { Client } from "soap";
-declare const _default: {
-    describeWSDL: DescribeWSDL;
-    generateHeader: GenerateHeader;
-    getSOAPAuth: SOAPAuth;
-    getSOAPClient: <T extends string | SOAPConnection = string | SOAPConnection>(wsdlParam: T) => Promise<Client>;
-    getWSDL: (wsdlDefinitionURL: string) => Promise<string>;
-    overrideClientDefaults: (client: Client, overrides: ClientOverrides) => void;
-    soapRequest: SOAPRequest;
-};
-export default _default;