Skip to main content
Below are all the public functions exposed on the Paragon SDK (which can be accessed as the named paragon export from @useparagon/connect) and public endpoints of the Paragon REST API. For on-premise users: If you are using an on-premise instance of Paragon, you can call the .configureGlobal function to point the SDK to use the base hostname of your Paragon instance. 
import { paragon } from "@useparagon/connect";

// If your login URL is https://dashboard.mycompany.paragon.so:
paragon.configureGlobal({
  host: "mycompany.paragon.so",
});

​
.authenticate(projectId: string, userToken: string)

.authenticate should be called at the beginning of your application’s lifecycle in all cases. This is to make sure that the userToken is always as fresh as possible, with respect to your user’s existing session on your own site.
JavaScript SDK
await paragon.authenticate(
  // You can find your project ID in the Overview tab of any Integration
  "38b1f170-0c43-4eae-9a04-ab85325d99f7",

  // See Setup for how to encode your user token
  "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.ey..."
);
Once .authenticate has been called, you can access the user’s integration state with .getUser(). .authenticate() only needs to be called when using the Paragon SDK - when making requests to the Paragon REST API, you should instead provide the Paragon User Token in the Authorization header.

​
.connect(integrationType: string, installOptions?: InstallOptions)

Call .connect to launch your Connect Portal for a specific integration provider. You can find the integrationType identifier you need in the Overview page for the integration.
JavaScript SDK
paragon.connect("salesforce");
This function must be called after the Paragon SDK has completed authentication. You can await the Promise returned by #.authenticate-projectid-string-usertoken-string to show a loading state before users are able to access the Connect Portal. You must have an integration configured of this integrationType in your Paragon project for the Connect Portal to appear. Otherwise, this function does nothing.
  • onSuccess Callback invoked when an integration is successfully enabled.
  • onError Callback if an unexpected error occurs.
  • accountType For integrations that support multiple account types, you can optionally designate a specific accountType to skip the account selection dialog.
    • default
    • sandbox
Example
paragon.connect("salesforce", {
  // Only allow production-type Salesforce accounts to connect
  accountType: "default",
});
You can also connect multiple accounts for the same integration.

Multi Account Authorization

​
.disableWorkflow(workflowId: string) -> Promise

Call .disableWorkflow to turn off a workflow for a user by ID. 
paragon.disableWorkflow("<Workflow ID>");

​
.enableWorkflow(workflowId: string) -> Promise

Call .enableWorkflow to turn on a workflow for a user by ID. 
paragon.enableWorkflow("<Workflow ID>");

​
.getDataSourceOptions(integrationType: string, sourceType: string)

Call .getDataSourceOptions to get configuration details for compound data sources used for dynamic User Settings types in the Headless Connect Portal. Compound data sources, for Field Mapping and Combo Dropdown inputs, have multiple data sources within them (Field Mappings have both Object Types and Field Names as sources). To load options for a data source, see getFieldOptions. Arguments:
​
integrationType
string
required
An integration type string, like salesforce.
​
sourceType
string
required
A source type string, which can be found in the sourceType property of a User Setting object from getIntegrationConfig or from stage.options of PostOptionsStage.
Examples: 
await paragon.getDataSourceOptions(
  "salesforce",
  "customObjectMapping",
);

// Returns:
{
  "id": "customObjectMapping",
  "type": "FIELD_MAPPER_DATA_SOURCE",
  "title": "Field Mapping",
  "subtitle": "Allows users to define a field mapping",
  "recordSource": {
    "type": "DYNAMIC_DATA_SOURCE",
    "title": "Record Type",
    "cacheKey": "recordTypes",
  },
  "fieldSource": {
    "type": "DYNAMIC_DATA_SOURCE",
    "title": "Field",
    "cacheKey": "cachedFields",
  },
}

​
.getFieldOptions(fieldOptions: FieldOptions)

Load options from an integration data source for dynamic User Settings types in the Headless Connect Portal, using the Connected User’s account. getFieldOptions() can only be called for data sources with type DYNAMIC_DATA_SOURCE (for dynamic enum input types).
  • Compound data sources like FIELD_MAPPER_DATA_SOURCE or COMBO_INPUT_DATA_SOURCE are composed of DYNAMIC_DATA_SOURCE-type sources.
  • When rendering Field Mapping or Combo Dropdown inputs, first identify each data source with getDataSourceOptions, and use the returned configuration to call getFieldOptions with the appropriate keys. See a full example.
This function supports search and pagination; see the parameters for fieldOptions below to learn more. Arguments:
​
fieldOptions
FieldOptions
required
​
integration
string
required
An integration type string, like salesforce.
​
action
string
required
A source type string, which can be found in the sourceType property of a User Setting object from getIntegrationConfig or from stage.options of PostOptionsStage.
​
search
string
A user-provided search query for an option. When provided, the data source will return options that match this query.
​
cursor
string
A page cursor to use to load subsequent pages of results. The response of getFieldOptions will provide nextPageCursor to use or null if there are no more results.
​
parameters
Parameter[]
When loading options for a compound data source (e.g. fieldSource of a Field Mapping input or dependentInputSource of a Combo Dropdown input), pass parameters with the user’s selection from the first input (e.g. the Record Type for Field Mapping).
​
key
string
The cacheKey property of the primary/first input in the compound data sources (e.g. recordSource of a Field Mapping input or mainInputSource of a Combo Dropdown input).
​
source
string
​
type
const
required
Set this to "VALUE".
​
value
string
required
Set this to the value property of the user’s selection.
Returns:
​
data
Option[] | Section[]
required
data will be an Array of either Option or Section objects, which should be handled by your Dropdown input.
  • Option
  • Section
​
label
string
required
The human-readable display name to use for this option when displaying it to your user.
​
value
string
required
The unique value of this option to save with setPreOptions, setPostOptions, updateIntegrationUserSettings, or updateWorkflowUserSettings. This value can also be passed as parameters[].source.value for dependent inputs of compound data sources.
​
nestedData
object[]
This section is an empty array for all input types except for Default value mapping, which is only supported by Jira: Issue Field Values.
​
nextPageCursor
string | null
The cursor value to pass as cursor for the next page of results.
Examples: 
await paragon.getFieldOptions({
  integration: "slack",
  action: "channels",
  search: "general",
});

// Returns:
{
  "data": [
    {
      "label": "#general",
      "value": "general"
    },
  ],
  "nestedData": [],
  "nextPageCursor": "dGVhbTpDMDUxWjlNSzk4Vw=="
}

​
.getIntegrationConfig(integrationType: string)

Call getIntegrationConfig to get the user-facing descriptions, User Settings, and Workflows associated with any integration. 
paragon.getIntegrationConfig("slack");

// Returns:
{
  "shortDescription": "Send notifications to Slack",
  "longDescription": "Connect your Slack workspace to receive notifications and alerts in Slack. Stay connected to important activity by bringing it all together in your Slack workspace.\n\nOur Slack integration enables you to:\n\n• Receive alerts and notifications in your Slack workspace\n• Notify or DM specific team members based on certain activity",
  "availableUserSettings": [
    {
      "id": "2d5662c9-6750-46c2-8588-2ac904532efb",
      "type": "DYNAMIC_ENUM",
      "title": "Channel",
      "required": false,
      "sourceType": "channels"
    }
  ],
  "availableWorkflows": [
    {
      "id": "2248335c-671c-47e4-b9a0-3641a9f2d301",
      "inputs": [],
      "infoText": "Send a Slack notification when a Task is created",
      "defaultEnabled": false,
      "description": "Send Slack Notification"
    }
  ],
  "hiddenWorkflows": []
}

​
.getIntegrationMetadata(integrationType: string?)

Call .getIntegrationMetadata to get the name, brandColor, and icon, for any of your active integration providers. This is a great way to create your integrations page! 
paragon.getIntegrationMetadata();

// Returns:
[
  {
    type: 'salesforce',
    name: 'Salesforce',
    brandColor: '#057ACF',
    icon: 'https://cdn.useparagon.com/2.35.0/dashboard/public/integrations/salesforce.svg'
  },
  {
    type: 'hubspot',
    name: 'Hubspot',
    brandColor: '#F67600',
    icon: 'https://cdn.useparagon.com/2.35.0/dashboard/public/integrations/hubspot.svg'
  },
  {
    type: 'slack',
    name: 'Slack',
    brandColor: '#4A154B',
    icon: 'https://cdn.useparagon.com/2.35.0/dashboard/public/integrations/slack.svg'
  }
]

​
.getUser() → ParagonUser

Call .getUser to retrieve the currently authenticated user and their connected integration state. A ParagonUser is an object shaped like: 
paragon.getUser();

// Response
{
	authenticated: true,
	userId: "xyz", // The user ID you specified in the signed JWT
	integrations: {
		salesforce: {
			configuredWorkflows: {},
			credentialId: "987654-56a7-89b1-cd23-456789abcdef",
			credentialStatus: "VALID",
			enabled: true
			providerData: {
				instanceURL: "https://mycompany.my.salesforce.com"
			},
			providerId: "1234567890"
		},
		shopify: {
			configuredWorkflows: {},
			enabled: false
		}
	}
}
If the user is not authenticated, you’ll receive back only { authenticated: false } instead. Please check the authenticated property before using the user.integrations field.

​
.event(name: string, json: JSON)

App Events can be sent from your application using the Paragon SDK or REST API. In both cases, you must pass two parameters:
  • name - the event name defined in your App Event
  • payload - the event payload that should match the event schema defined in your App Event
See the code examples below for how to send App Events using the Paragon SDK or API. 
var eventName = "Contact Created";
var eventPayload = { "name": "Brandon", "email": "[email protected]" };

// Called once during your user's session
paragon.authenticate("project-id", <Paragon User Token>);

// Trigger the "Contact Created" App Event
paragon.event(eventName, eventPayload);
When sending live events from your application, Paragon will not validate that your event payload matches the defined event schema.

​
.installIntegration(integrationType: string, installOptions?: InstallOptions) -> Promise<IntegrationInstallEvent>

This function should be used only if you are using your own components to show connected integrations and their status, instead of the Connect Portal.Otherwise, you can use the .connect function.
The .installIntegration can be used to start the connection process for an integration without the Connect Portal appearing over your user interface. You can find the integrationType identifier you need in the Overview page for the integration. This function resolves with the IntegrationInstallEvent in the same format available in paragon.subscribe. You can use this to get the newly created credential by awaiting the returned Promise. This function rejects the returned Promise if the integration is already installed for the authenticated user.
JavaScript SDK
const { credential } = await paragon.installIntegration("googledrive");
Note: If the integration specified by integrationType requires API keys or post-authentication options, the Connect Portal will still appear to capture those values from your user at that time. The Connect Portal will automatically be dismissed after those values are entered. This function accepts the same optional install options as #.connect-integration.

​
.subscribe(eventName: string, handler: Function)

Call .subscribe to subscribe to different events and changes from the Paragon SDK. You can find the possible eventNames below:
Event TypeUsage in .subscribe()Usage in .connect()
Integration enabled"onIntegrationInstall""onInstall"
Integration disabled"onIntegrationUninstall""onUninstall"
Workflow state change"onWorkflowChange""onWorkflowChange"
Connect Portal opened"onPortalOpen""onOpen"
Connect Portal closed"onPortalClose""onClose"
Subscribing to SDK Events applies to all integrations globally. Specifying callbacks to .connect() only applies to a currently open Connect Portal locally. See the code examples below for how to subscribe to events using the Paragon SDK. 
type IntegrationInstallEvent = {
  integrationId: string;
  integrationType: VisibleConnectAction;
  credential: Credential;
  credentialId: string;
};

// Using global subscribe
paragon.subscribe(
  "onIntegrationInstall",
  (event: IntegrationInstallEvent, user: AuthenticatedConnectUser) => {
    /* ... */
  }
);
Alternatively, you can subscribe onOpen, onClose, onUninstall , and onWorkflowChange as a one-time event locally. 
type IntegrationInstallEvent = {
  integrationId: string;
  integrationType: VisibleConnectAction;
  credential: Credential;
  credentialId: string;
};

// Using local call to paragon.connect
paragon.connect("<integration>", {
  onInstall: (
    event: IntegrationInstallEvent,
    user: AuthenticatedConnectUser
  ) => {
    /* ... */
  },
});

​
.request(integrationType: string, path: string, requestOptions: RequestInit ) → Promise

Call .request to send an API request to a third-party integration on behalf of one of your users. Every integration in your dashboard has a code example of using paragon.request, which takes three arguments:
  • integrationType: The short name for the integration. i.e. “salesforce” or “googleCalendar”. You can find this string on the Overview tab of the integration you want to access, on your Paragon dashboard.
  • path: The path (without the hostname) of the API request you are trying to access. An example might be: “/v1/charges” for Stripe’s charge API or “chat.postMessage” for Slack’s Web API.
  • requestOptions: Request options to include, such as:
    • body: An object representing JSON contents of the request.
    • method: An HTTP verb such as “GET” or “POST”. Defaults to GET.
The function returns a promise for the request output, which will have a shape that varies depending on the integration and API endpoint. 
await paragon.request('slack', '/chat.postMessage', {
	method: 'POST',
	body: {
		channel: 'CXXXXXXX0' // Channel ID,
		text: 'This message was sent with Paragon Connect :exploding_head:'
	}
});

// -> Responds with { ok: true }, and sends a message :)

​
.setUserMetadata(meta: object)

Call .setUserMetadata() to associate the authenticated user with metadata from your application. This metadata can be accessed with .getUser() or retrieved over the API. 
paragon.setUserMetadata({
  Name: "Sean V",
  Email: "[email protected]",
  apiKey: "key_Y0kBVldPFInxK",
});

​
.uninstallIntegration(integrationType: string) -> Promise

Call .uninstallIntegration() to disconnect an integration for the authenticated user. When an integration is disconnected, workflows for that integration will stop running for the authenticated user and any saved User Settings will be cleared. 
// Use the integration name, as used in paragon.connect();
await paragon.uninstallIntegration("salesforce");

​
.updateIntegrationUserSettings(integrationType: string, userSettingsUpdate: object, options?: CredentialConfigOptions)

Call .updateIntegrationUserSettings() to update any integration-level User Settings for your Connected User. Arguments:
​
integrationType
string
required
An integration type string, like salesforce.
​
userSettingsUpdate
object
required
A partial update object where the keys are the id properties of User Settings objects (which you can get from getIntegrationConfig) and the values are the user’s selection for the matching input type.Any keys that are not included in the object will not be updated.The type for each value will depend on the input type. See Input Types Reference to see the value type for each input.
Example
{
  "1f7474a5-8b8e-4c25-8d44-29f20aec3fe4": "general"
}
​
options
CredentialConfigOptions | undefined
Optionally specify a Credential and Configuration to target, if using Multi-Account Authorization or Multi-Configuration.
​
selectedCredentialId
string
The Credential ID (a UUID) of the connected account you want to update, if using Multi-Account Authorization.
​
selectedConfigurationId
string
The Configuration ID (a UUID or an External ID prefixed with ext:), if using Multi-Configuration.

​
.updateWorkflowState(workflowStateUpdate: object, options?: CredentialConfigOptions)

Call .updateWorkflowState() to enable or disable workflows for a user. Arguments:
​
workflowStateUpdate
object
required
A partial update object where keys are workflow IDs and values are true or false. Any workflow IDs not included in this object will not be updated in this call.
Example
{
  "bb89897b-ec2a-4118-b091-c12713c6bffa": true,
  "487c67e1-bc3f-406e-acc4-085f897dc564": false,
}
​
options
CredentialConfigOptions | undefined
Optionally specify a Credential and Configuration to target, if using Multi-Account Authorization or Multi-Configuration.
​
selectedCredentialId
string
The Credential ID (a UUID) of the connected account you want to update, if using Multi-Account Authorization.
​
selectedConfigurationId
string
The Configuration ID (a UUID or an External ID prefixed with ext:), if using Multi-Configuration.

​
.updateWorkflowUserSettings(integrationType: string, workflowId: string, userSettingsUpdate: object, options?: CredentialConfigOptions)

Call .updateWorkflowUserSettings() to update any workflow-level User Settings for your Connected User. Arguments:
​
integrationType
string
required
An integration type string, like salesforce.
​
workflowId
string
required
The ID of the Workflow that the workflow-level User Setting you are modifying belongs to. If you are trying to modify an integration-level User Setting, call updateIntegrationUserSettings instead.
​
userSettingsUpdate
object
required
A partial update object where the keys are the id properties of User Settings objects (which you can get from getIntegrationConfig) and the values are the user’s selection for the matching input type.Any keys that are not included in the object will not be updated.The type for each value will depend on the input type. See Input Types Reference to see the value type for each input.
Example
{
  "1f7474a5-8b8e-4c25-8d44-29f20aec3fe4": "general"
}
​
options
CredentialConfigOptions | undefined
Optionally specify a Credential and Configuration to target, if using Multi-Account Authorization or Multi-Configuration.
​
selectedCredentialId
string
The Credential ID (a UUID) of the connected account you want to update, if using Multi-Account Authorization.
​
selectedConfigurationId
string
The Configuration ID (a UUID or an External ID prefixed with ext:), if using Multi-Configuration.

​
.workflow(workflowId: string, options: FetchOptions)

Call .workflow() to trigger a Paragon workflow that sends a custom response back to your app. Note: The workflow must be enabled and use a Request-type trigger. 
// Called once during your user's session
paragon.authenticate("project-id", <Paragon User Token>)

// Trigger the "Lead Created" workflow
await paragon.workflow("<workflow_id>", {
  "body": {
    "email": "[email protected]",
    "first_name": "Bowie",
    "last_name": "Foo"
  }
});

​
Get project’s integrations

Returns a list of the integrations enabled for the Paragon project by the ID in the URL.
  • Includes the Connect Portal configuration for each integration (as .configs) and the Workflows associated with each integration (as .workflows)
You can use getIntegrationMetadata and getIntegrationConfig when using the JavaScript SDK.
REST API
GET https://api.useparagon.com/projects/<Paragon Project ID>/sdk/integrations

Authorization: Bearer <Paragon User Token>
Content-Type: application/json

// Example response (may include more than is in this list):

[{
  "id": "2f08e65f-d924-42ab-9618-b6023d82ffbd",
  "projectId": "908f4c5e-6394-46a5-9355-3f729edbd160",
  "customIntegrationId": null,
  "type": "slack",
  "isActive": true,
  "configs": [
    {
      "id": "3ebcc179-a1a6-447f-8dc9-5017f40f08ef",
      "values": {
        "overview": "####Our Slack integration enables you to:\n   \n\n• Receive alerts and notifications in your Slack workspace\n• Notify or DM specific team members based on certain activity",
        "sharedMeta": {},
        "accentColor": "#4A154B",
        "description": "Send notifications to Slack",
        "workflowMeta": {}
      }
    },
  ],
  "workflows": [
    {
      "id": "1b22193b-e355-458d-b6a3-5e5516edb588",
      "description": "Send Updates to Slack",
      "projectId": "908f4c5e-6394-46a5-9355-3f729edbd160",
      "integrationId": "2f08e65f-d924-42ab-9618-b6023d82ffbd",
      "steps": []
    }
  ],
  "customIntegration": null,
  "hasCredential": true,
  "connectedUserLimitOnDevCred": 0,
  "connectedUserLimitReached": true,
  "name": "Slack",
  "brandColor": "#4A154B",
  "needPreOauthInputs": false,
  "providerType": "slack",
  "authenticationType": "oauth"
}]

​
Get user’s Connect credentials

Returns a list of the user’s Connect credentials (i.e., the accounts connected and authorized by the end user).
  • The providerId is the authenticated user’s ID assigned by their integration provider (e.g. for a Salesforce integration, this would be the user’s Salesforce user ID)
This method is currently available via REST API only.
REST API
GET https://api.useparagon.com/projects/<Paragon Project ID>/sdk/credentials

Authorization: Bearer <Paragon User Token>
Content-Type: application/json

// Example response (may include more than is in this list):

[{
  "id": "00da4146-7ac4-4253-a8f7-96849b8137d9",
  "dateCreated": "2021-03-24T12:19:21.511Z",
  "dateUpdated": "2021-03-24T12:19:28.512Z",
  "dateDeleted": null,
  "projectId": "db06d291-ba2c-41c5-9a12-9362abfd6228",
  "integrationId": "95bedc9f-6a22-4855-b08d-e68dc073ad91",
  "personaId": "0563109f-5e71-46c5-8483-1ac8c0913d6c",
  "config": {
    "configuredWorkflows": {
      "3eb95154-3c7b-413c-bf14-ba367d95b53f": {
        "enabled": true,
        "settings": {
					"example-input-id": "example value"
				}
      }
    }
  },
  "isPreviewCredential": false,
  "providerId": "50150244515"
}]

​
Update user’s Connect credential

Updates the user’s connected integration account, including any settings and configured workflows. This endpoint updates by replacement with respect to the config property, so this endpoint should only be used after retrieving the existing value (which can be done by using the above endpoint: Get user’s Connect credentials). Alternatively, you can use the SDK to update User Settings or workflow enablements:
REST API
PATCH https://api.useparagon.com/projects/<Paragon Project ID>/sdk/credentials/<Connect Credential ID>

Authorization: Bearer <Paragon User Token>
Content-Type: application/json

// Body: Example showing <Workflow ID> being enabled
{
    "config": {
        "configuredWorkflows": {
            ...
            "<Workflow ID>": {
                "enabled": true,
                "settings": {}
            }
        },
        "sharedSettings": {...}
    }
}
Note: In the above example, the existing value for config must be provided in full, with the intended changes applied. This is because config will be updated by replacement.

​
installFlow

Use installFlow when implementing the Headless Connect Portal to guide your user through the installation process for an integration.

​
installFlow.start(integrationType, options)

Call installFlow.start() to begin an install flow for an integration. See an example call. Arguments:
​
integrationType
string
required
The integration type string, like salesforce.
​
options
object
required

Show child properties

​
onNext(nextStage)
function
This callback is called when the install flow is ready to move to the next stage.Your app must render the appropriate UI for each stage, so that your user can provide the necessary details in that stage to connect their account.
​
nextStage
InstallFlowStage
The install flow stage for your app to render.
  • AccountTypeStage
  • PreOptionsStage
  • PostOptionsStage
In the AccountTypeStage, the user should be prompted with a list of account types that they can choose from.If you want to skip this stage, pass the first account type option (or "default") to installFlow.setAccountType() to move to the next stage.
Example (Salesforce)
{
  "stage": "accountType",
  "options": [
    { "id": "default", "accountDescription": "Production Account" },
    { "id": "sandbox", "accountDescription": "Sandbox Account"}
  ]
}
​
stage
const
"accountType" for AccountTypeStage.
​
options
AccountType[]
The list of account types that the user can choose from.
​
id
string
required
The ID of the account type. Pass this to installFlow.setAccountType() when the user selects an option.
​
accountDescription
string
The human-readable description of the account type.
​
onComplete()
function
This callback is called when the install flow completes successfully.
​
onError(error, context)
function
This callback is called when the install flow fails, with an error object and error context.
​
error
Error
The error object. You can read the .name of the error object to identify one of the following error types:
  • OAuthBlockedError: The browser blocked the OAuth prompt from appearing. This may require the user to allow popups in their browser settings.
  • OAuthTimeoutError: The OAuth prompt took longer than oauthTimeout milliseconds (as provided in options) to complete.
  • UserNotAuthenticatedError: The user is not authenticated with the Paragon SDK. Verify that paragon.authenticate() has been called before starting the install flow.
  • NoActiveInstallFlowError: An install flow function was called, but no install flow is currently active. Call start() to start an install flow.
  • HeadlessModeNotEnabledError: Headless Connect Portal is not enabled. Call paragon.setHeadless(true) to enable Headless mode.
  • IntegrationNotFoundError: The provided integration type is not found or has not been enabled in your Paragon project.
​
context
ErrorContext | null
The error context object.
​
stage
InstallFlowStage
The stage that the install flow was on when the error occurred.One of: accountType, preOptions, postOptions.
​
oauthTimeout
number
The number of milliseconds to wait for an OAuth prompt to complete. If the user does not complete the OAuth prompt within this time, the install flow will fail, and the onError callback will be called.If not provided, there will be no timeout for the OAuth prompt.

​
installFlow.setAccountType(accountType)

Call installFlow.setAccountType(accountType) when the user selects an account type in the AccountTypeStage. Arguments:
​
accountType
string
required
The account type to set. This should be the id property of the Account Type option that the user selected.

​
installFlow.setPreOptions(values)

Call installFlow.setPreOptions(values) when the user finishes providing inputs in the PreOptionsStage. This returns a Promise that resolves when the values are saved. Upon success, the install flow will move to the next stage and call onNext. If there is no stage after the PreOptionsStage, the install flow will call onComplete. Arguments:
​
values
object
required
The values to set for the inputs in the PreOptionsStage.This should be an object, where the keys are ids of the inputs in the PreOptionsStage, and the values are the values that the user provided for each input.
Example (Shopify)
await paragon.installFlow.setPreOptions({
  "SHOP_NAME": "my-shop"
});

​
installFlow.setPostOptions(values)

Call installFlow.setPostOptions(values) when the user finishes providing inputs in the PostOptionsStage. This returns a Promise that resolves when the values are saved. Upon success, the install flow will be completed and call onComplete. Arguments:
​
values
object
required
The values to set for the inputs in the PostOptionsStage.This should be an object, where the keys are ids of the inputs in the PostOptionsStage, and the values are the values that the user provided for each input.
Example (Jira)
await paragon.installFlow.setPostOptions({
  "JIRA_CLOUD_ID": "my-jira-cloud-id"
});

​
ExternalFilePicker

You can use the Paragon SDK to allow your user to select files from a File Storage integration in your app. The SDK provides an ExternalFilePicker class to load any necessary JavaScript dependencies into your page and authenticate with your user’s connected account.

​
Supported integrations for ExternalFilePicker

​
new paragon.ExternalFilePicker(integrationType, options)

Construct a new instance of an ExternalFilePicker for an integration given by integrationType. Any required JS dependencies do not start loading until .init is called. Example: 
const picker = new paragon.ExternalFilePicker("googledrive", {
  allowedTypes: ["application/pdf"],
  allowMultiSelect: false,
  onFileSelect(files) {
    console.log("User picked files", files);
  },
});

​
Options

  • allowedTypes (default: undefined)
    • An array of MIME types to allow for file selection, e.g. ["application/pdf", "image/jpeg"]
    • If undefined, all types will be allowed.
  • allowMultiSelect (default: false)
    • If true, allow multiple files to be selected.
  • allowFolderSelect (default: false)
    • If true, allow folders to be selected.
  • onOpen()
    • Called when a Picker successfully appears in the app.
  • onClose()
    • Called when a Picker gets closed.
  • onFileSelect(files)
    • Called when a Picker file selection is made.
    • files is an Array of objects with the selected file objects from the 3rd-party picker script.
  • onCancel()
    • Called when a Picker gets closed without any files selected.

​
picker.init(initConfig)

Initialize a file picker with required configuration initConfig. Required configuration varies per integration; see integration-specific documentation for specific details. This function loads required JS dependencies into the page, if they have not already been loaded. Other methods, like .open and .getInstance, cannot be called until the Promise returned by .init is resolved. Example: 
await picker.init({
  // Google Developer Key
  developerKey: "AIzaS...",
});
initConfig also accepts selectedCredentialId, which can be passed to select a specific account to pick files from when using Multi-Account Authorization.

​
picker.open()

Presents the file picker in your app. Selected files or other events will be received in the callbacks you specified in the constructor. Example: 
picker.open();

​
picker.getInstance()

Returns a reference to the third-party JS library object that this file picker is using. This object can be used for additional integration-specific customization.
⌘I