@useparagon/connect 1.0.0 → 1.0.1

package/dist/src/types/resolvers.d.ts

@@ -0,0 +1,297 @@
+/// <reference types="node" />
+import { TokenType } from './action';
+import { FanoutStackEntry } from './execution';
+export declare enum DataType {
+    STRING = "STRING",
+    NUMBER = "NUMBER",
+    DATE = "DATE",
+    BOOLEAN = "BOOLEAN",
+    EMAIL = "EMAIL",
+    OBJECT = "OBJECT",
+    ARRAY = "ARRAY",
+    ANY = "ANY",
+    FILE = "FILE",
+    NON_DECIMAL = "NON_DECIMAL"
+}
+export type TokenizedSource<T extends DataType = DataType> = {
+    dataType?: T;
+    type: 'TOKENIZED';
+    parts: TokenizedValue[];
+};
+type TokenizedValue<T extends DataType = DataType> = ValueSource<T> | VariableSource<T> | SecretSource | ConnectCredentialSource | ObjectValueSource | PersonaMetadataSource;
+type ObjectValueSource<T extends DataType = DataType> = {
+    type: 'OBJECT_VALUE';
+    name: string;
+    path: string[];
+    dataType?: T;
+};
+type VariableSource<T extends DataType = DataType> = {
+    dataType?: T;
+    type: 'VARIABLE';
+    stepId: string;
+    path: string[];
+};
+type SecretSource = {
+    type: 'ENVIRONMENT_SECRET';
+    environmentSecretId: string;
+};
+type ValueSource<T extends DataType = DataType> = {
+    dataType?: T;
+    type: 'VALUE';
+    value: DataTypeValues[T];
+};
+type ConnectCredentialSource = {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'WORKFLOW_SETTING';
+    inputId: string;
+    /**
+     * @since PARA-3065: ConnectInputValue can now include more than a string/number type, so a
+     * path is specified similarly to VariableSource to traverse object types.
+     */
+    path?: string[];
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'SHARED_WORKFLOW_SETTING';
+    inputId: string;
+    path?: string[];
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'EXTERNAL_USER_ID';
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'EXTERNAL_USER_PROVIDER_ID';
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'OAUTH_ACCESS_TOKEN';
+} | {
+    type: 'CONNECT_CREDENTIAL_FIELD';
+    fieldType: 'EXTERNAL_USER_PROVIDER_DATA';
+    dataKey: string;
+};
+type PersonaMetadataSource = {
+    type: 'PERSONA_METADATA';
+    path?: string[];
+};
+type DataTypeValues = {
+    [DataType.STRING]: string;
+    [DataType.NUMBER]: number;
+    [DataType.DATE]: Date;
+    [DataType.BOOLEAN]: boolean;
+    [DataType.EMAIL]: string;
+    [DataType.OBJECT]: object;
+    [DataType.ARRAY]: any[];
+    [DataType.ANY]: any;
+    [DataType.FILE]: FileValue;
+    [DataType.NON_DECIMAL]: number;
+};
+type FileDataType = Buffer;
+type FileValue = {
+    data: FileDataType;
+    dataType: DataType.FILE;
+    encoding?: string;
+    id?: string;
+    mimeType?: string;
+    name?: string;
+    size?: string;
+};
+export type KeyedSource<T extends DataType = DataType> = {
+    key: string;
+    source: Source<T>;
+};
+export type Source<T extends DataType = DataType> = ValueSource<T> | VariableSource<T> | TokenizedSource<T> | ConditionSource | SecretSource | ExecutionSource | FanoutExecutionSource | UserSuppliedCredentialSource | ConnectCredentialSource | ObjectValueSource | PersonaMetadataSource;
+type ConditionSource = {
+    type: 'CONDITION';
+    condition: ConditionWrapper;
+};
+type ConditionWrapper = JoinedConditions | OperatorCondition;
+type JoinedConditions = AndConditions | OrConditions;
+type AndConditions = {
+    type: 'JOIN';
+    join: 'AND';
+    conditions: ConditionWrapper[];
+};
+export type OrConditions = {
+    type: 'JOIN';
+    join: 'OR';
+    conditions: ConditionWrapper[];
+};
+type OperatorCondition = {
+    type: 'OPERATOR';
+    condition: Condition;
+};
+type Condition = {
+    operator: Operator.None;
+    variable: Source<DataType.ANY>;
+} | {
+    operator: Operator.StringContains;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotContain;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringExactlyMatches;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotExactlyMatch;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringIsIn;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringIsNotIn;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringStartsWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotStartWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringEndsWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringDoesNotEndWith;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.NumberGreaterThan;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberLessThan;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberGreaterThanOrEqualTo;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberLessThanOrEqualTo;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberEquals;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.NumberDoesNotEqual;
+    variable: Source<DataType.NUMBER>;
+    argument: Source<DataType.NUMBER>;
+} | {
+    operator: Operator.DateTimeAfter;
+    variable: Source<DataType.DATE>;
+    argument: Source<DataType.DATE>;
+} | {
+    operator: Operator.DateTimeBefore;
+    variable: Source<DataType.DATE>;
+    argument: Source<DataType.DATE>;
+} | {
+    operator: Operator.DateTimeEquals;
+    variable: Source<DataType.DATE>;
+    argument: Source<DataType.DATE>;
+} | {
+    operator: Operator.BooleanTrue;
+    variable: Source<DataType.BOOLEAN>;
+} | {
+    operator: Operator.BooleanFalse;
+    variable: Source<DataType.BOOLEAN>;
+} | {
+    operator: Operator.IsNull;
+    variable: Source;
+} | {
+    operator: Operator.IsNotNull;
+    variable: Source;
+} | {
+    operator: Operator.Exists;
+    variable: Source;
+} | {
+    operator: Operator.DoesNotExist;
+    variable: Source;
+} | {
+    operator: Operator.ArrayIsEmpty;
+    variable: Source<DataType.ARRAY>;
+} | {
+    operator: Operator.ArrayIsNotEmpty;
+    variable: Source<DataType.ARRAY>;
+} | {
+    operator: Operator.StringGreaterThan;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+} | {
+    operator: Operator.StringLessThan;
+    variable: Source<DataType.STRING>;
+    argument: Source<DataType.STRING>;
+};
+declare enum Operator {
+    'None' = "$none",
+    'StringContains' = "$stringContains",
+    'StringDoesNotContain' = "$stringDoesNotContain",
+    'StringExactlyMatches' = "$stringExactlyMatches",
+    'StringDoesNotExactlyMatch' = "$stringDoesNotExactlyMatch",
+    'StringIsIn' = "$stringIsIn",
+    'StringIsNotIn' = "$stringIsNotIn",
+    'StringStartsWith' = "$stringStartsWith",
+    'StringDoesNotStartWith' = "$stringDoesNotStartWith",
+    'StringEndsWith' = "$stringEndsWith",
+    'StringDoesNotEndWith' = "$stringDoesNotEndWith",
+    'NumberGreaterThan' = "$numberGreaterThan",
+    'NumberLessThan' = "$numberLessThan",
+    'NumberEquals' = "$numberEquals",
+    'NumberDoesNotEqual' = "$numberDoesNotEqual",
+    'NumberLessThanOrEqualTo' = "$numberLessThanOrEqualTo",
+    'NumberGreaterThanOrEqualTo' = "$numberGreaterThanOrEqualTo",
+    'DateTimeAfter' = "$dateTimeAfter",
+    'DateTimeBefore' = "$dateTimeBefore",
+    'DateTimeEquals' = "$dateTimeEquals",
+    'BooleanTrue' = "$booleanTrue",
+    'BooleanFalse' = "$booleanFalse",
+    /** (PARA-5551) previously operators for Does Exist / Does Not Exist do a strict check for equality to null, resulting in a bug where value is undefined
+     * to handle this situation, we are adding 2 new operators IsNotNull and IsNull and changing functionality of
+     * Exist and DoesNotExist operators to handle undefined values
+     */
+    'IsNotNull' = "$exists",
+    'IsNull' = "$doesNotExist",
+    'Exists' = "$isNotUndefinedOrNull",
+    'DoesNotExist' = "$isUndefinedOrNull",
+    'ArrayIsIn' = "$arrayIsIn",
+    'ArrayIsNotIn' = "$arrayIsNotIn",
+    'ArrayIsEmpty' = "$arrayIsEmpty",
+    'ArrayIsNotEmpty' = "$arrayIsNotEmpty",
+    'StringGreaterThan' = "$stringGreaterThan",
+    'StringLessThan' = "$stringLessThan"
+}
+type ExecutionSource = {
+    type: 'EXECUTION';
+    id: string;
+    stepId: string;
+    /**
+     * a timestamp representing when the execution occurred
+     */
+    start: number;
+    fanoutStack: FanoutStackEntry[];
+    /**
+     * This flag suggests that the content of the variable will be stored on remmote storage service
+     * such as s3
+     */
+    remoteCached?: boolean;
+};
+type FanoutExecutionSource = {
+    type: 'FANOUT_EXECUTION';
+    stepId: string;
+};
+type UserSuppliedCredentialSource = {
+    type: 'USER_SUPPLIED_CREDENTIAL';
+    tokenType: TokenType;
+    providerType: string;
+    credential: TokenizedSource<DataType.STRING>;
+};
+export {};

package/dist/src/types/sdk.d.ts

@@ -0,0 +1,223 @@
+import ConnectSDK from '../ConnectSDK';
+import { OauthCallbackResponse } from '../entities/credential.interface';
+import { IIntegrationMetadata } from '../entities/integration.interface';
+import { PersonaMeta } from '../entities/persona.interface';
+import { IConnectUserContext } from '../helpers/ConnectUserContext';
+import { AuthenticatedConnectUser, DynamicMappingField, DynamicMappingOptions, IntegrationWorkflowState } from '../types/connect';
+import { Props as ConnectModalProps } from './connectModal';
+export type ConnectUser = {
+    authenticated: false;
+} | AuthenticatedConnectUser;
+export type FunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? K : never;
+}[keyof T];
+type NonFunctionPropertyNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K;
+}[keyof T];
+export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;
+export type UnwrapPromise<T> = T extends PromiseLike<infer U> ? U : T;
+export type NonNullUndefinedField<T> = {
+    [P in keyof T]-?: NonNullUndefinedField<NonNullable<T[P]>>;
+};
+export type UIUpdateMessage = {
+    messageType: 'UI_UPDATE';
+    nextContext: NonFunctionProperties<IConnectUserContext>;
+    nextModalState: NonFunctionProperties<ConnectModalProps>;
+};
+export type SDKFunctionInvocationMessage<T extends FunctionPropertyNames<ConnectSDK> = never> = {
+    messageType: 'SDK_FUNCTION_INVOCATION';
+    type: T;
+    parameters: Parameters<ConnectSDK[T]>;
+    id: string;
+};
+export type SDKFunctionResponseMessage<T extends FunctionPropertyNames<ConnectSDK> = never> = {
+    messageType: 'SDK_FUNCTION_RESPONSE';
+    type: T;
+    result: UnwrapPromise<ReturnType<ConnectSDK[T]>>;
+    id: string;
+};
+export type SDKFunctionErrorMessage = {
+    messageType: 'SDK_FUNCTION_ERROR';
+    error: true;
+    message: string;
+    id: string;
+};
+export type SDKReceivedMessage = SDKFunctionInvocationMessage;
+export interface IConnectSDK {
+    authenticate(projectId: string, token: string, options?: AuthenticateOptions): Promise<void>;
+    connect(action: string): void;
+    getUser(): ConnectUser;
+    /**
+     * **Do not call this function directly.**
+     *
+     * Invoked by the OAuth popup after finishing the credential exchange.
+     * @private
+     */
+    _oauthCallback(credential: OauthCallbackResponse): Promise<void>;
+    /**
+     * **Do not call this function directly.**
+     *
+     * Invoked by the OAuth popup on an error encountered during the credential exchange.
+     * @private
+     */
+    _oauthErrorCallback(errorMessage: string): Promise<void>;
+    /**
+     * installs an integration without the need to click on enable button from portal
+     * Install Options:
+     * `{showPortalAfterInstall: boolean}` decides wether to show portal with configuration view after the installation is completed
+     */
+    installIntegration(name: string, options: InstallOptions): Promise<void>;
+    /**
+     * uninstalls an integration for connected user.
+     */
+    uninstallIntegration(name: string): Promise<void>;
+    /**
+     * disables a workflow for the connected user and unsubscribes all the workflows in hermes
+     */
+    disableWorkflow(workflowId: string): Promise<void>;
+    setUserMetadata(meta: PersonaMeta): Promise<AuthenticatedConnectUser>;
+    /**
+     * sets the base url for different services used in connect sdk
+     */
+    configureGlobal(options: {
+        host: string;
+    }): void;
+    /**
+     * returns metadata for given integration
+     * @param integrationName integration name
+     */
+    getIntegrationMetadata(integrationName: string): IIntegrationMetadata;
+    getIntegrationMetadata(): IIntegrationMetadata[];
+    /**
+     * triggers all workflows for event
+     * @param name eventName
+     * @param payload event payload object
+     */
+    event(name: string, payload: Record<string, unknown>): Promise<void>;
+    /**
+     * makes an connect proxy action request
+     * @param action actionName
+     * @param path request path
+     * @param init request initialization options {method: httpMethod, body:RequestBody, header}
+     */
+    request<TResponse>(action: string, path: string, init: {
+        method: RequestInit['method'];
+        body: RequestInit['body'] | object;
+        headers: RequestInit['headers'];
+    }): Promise<TResponse | undefined>;
+    /**
+     * listen on connect sdk events
+     * @param eventName SDKEVENTS
+     * @param listener
+     */
+    subscribe(eventName: SDK_EVENT, listener: ListenerFunction): () => boolean;
+    /**
+     * remove listeners on connect sdk events
+     * @param eventName SDKEVENTS
+     * @param listener
+     */
+    unsubscribe(eventName: SDK_EVENT, listener: ListenerFunction): boolean;
+    /**
+     * trigger connect endpoint trigger workflow
+     * @param workflowId
+     * @param triggerWorkflowRequest
+     */
+    workflow(workflowId: string, triggerWorkflowRequest: TriggerWorkflowRequest): Promise<object | undefined>;
+}
+/**
+ * sdk install options
+ */
+export type InstallOptions = {
+    /**
+     * api only install or ui install
+     */
+    isApiInstallation?: boolean;
+    /**
+     * if true show portal when install with api install option
+     */
+    showPortalAfterInstall?: boolean;
+    /**
+     * not show post oauth promt if this is true
+     */
+    bypassPostOAuthPrompt?: boolean;
+};
+export type AuthenticateOptions = {
+    metadata?: PersonaMeta;
+};
+/**
+ * Connect Modal Tabs
+ */
+export declare enum ModalView {
+    OVERVIEW = "overview",
+    CONFIGURATION = "configuration"
+}
+export type IntegrationInstallEvent = {
+    integrationId: string;
+    integrationType: string;
+};
+export type IntegrationUninstallEvent = IntegrationInstallEvent;
+export type WorkflowStateChangeEvent = {
+    integrationId: string;
+    workflowId: string;
+    workflowStateChange: Partial<IntegrationWorkflowState>;
+};
+export type PortalOpenEvent = {
+    integrationId: string;
+    integrationType: string;
+};
+export type PortalCloseEvent = PortalOpenEvent;
+export type CallbackMap = {
+    onSuccess?: (event: IntegrationInstallEvent, user: AuthenticatedConnectUser) => void;
+    onInstall?: (event: IntegrationInstallEvent, user: AuthenticatedConnectUser) => void;
+    onError?: (err: Error) => void;
+    onUninstall?: (event: IntegrationUninstallEvent, user: AuthenticatedConnectUser) => void;
+    onWorkflowChange?: (event: WorkflowStateChangeEvent, user: AuthenticatedConnectUser) => void;
+    onOpen?: (event: PortalOpenEvent, user: AuthenticatedConnectUser) => void;
+    onClose?: (event: PortalCloseEvent, user: AuthenticatedConnectUser) => void;
+};
+export type UserProvidedIntegrationConfig = {
+    /**
+     * used to override redirect url passed in getAuthUrl instead of our passport url
+     */
+    overrideRedirectUrl?: string;
+    /**
+     * This will allow users to provide dynamic fields options for object mapping inputs
+     */
+    mapObjectFields?: {
+        [objectName: string]: DynamicMappingField[] | DynamicMappingOptions;
+    };
+};
+export type ConnectParams = CallbackMap & UserProvidedIntegrationConfig & InstallOptions;
+export type EventInfo = {
+    type: SDK_EVENT;
+    integrationId: string;
+    integrationType: string;
+    workflowId?: string;
+    workflowStateChange?: Partial<IntegrationWorkflowState>;
+};
+export declare enum SDK_EVENT {
+    ON_INTEGRATION_INSTALL = "onIntegrationInstall",
+    ON_INTEGRATION_UNINSTALL = "onIntegrationUninstall",
+    ON_WORKFLOW_CHANGE = "onWorkflowChange",
+    ON_PORTAL_OPEN = "onPortalOpen",
+    ON_PORTAL_CLOSE = "onPortalClose"
+}
+export type SDKEventListenerMap = {
+    [SDK_EVENT.ON_INTEGRATION_INSTALL]: Array<(event: IntegrationInstallEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_INTEGRATION_UNINSTALL]: Array<(event: IntegrationUninstallEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_PORTAL_CLOSE]: Array<(event: PortalCloseEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_PORTAL_OPEN]: Array<(event: PortalOpenEvent, user: AuthenticatedConnectUser) => void>;
+    [SDK_EVENT.ON_WORKFLOW_CHANGE]: Array<(event: WorkflowStateChangeEvent, user: AuthenticatedConnectUser) => void>;
+};
+export type ListenerFunction = SDKEventListenerMap[keyof SDKEventListenerMap][number];
+export declare enum DocumentLoadingState {
+    LOADING = "loading",
+    INTERACTIVE = "interactive",
+    COMPLETE = "complete"
+}
+export type TriggerWorkflowRequest = {
+    body?: RequestInit['body'] | object;
+    headers?: RequestInit['headers'];
+    query?: Record<string, string>;
+};
+export {};

package/dist/src/types/stripe.d.ts

@@ -0,0 +1,23 @@
+export declare enum BillingPlan {
+    ClassicFree = "free",
+    ClassicStarter = "starter",
+    ClassicBusiness = "business",
+    ClassicPremium = "premium",
+    ClassicEnterprise = "enterprise",
+    ConnectTrial = "connect_trial",
+    ConnectBasic = "basic",
+    ConnectPro = "pro",
+    ConnectEnterprise = "connect_enterprise"
+}
+export declare enum ConnectAddOn {
+    CustomIntegrationBuilder = "byo",
+    DynamicFieldMapper = "dfm",
+    HeadlessConnectPortal = "headless-cp",
+    TaskHistoryAPI = "th-api",
+    Monitoring = "monitoring",
+    RoleBasedAccessControl = "rbac",
+    UserMetadata = "user-metadata",
+    WhiteLabeling = "whitelabel",
+    WorkflowPermission = "workflow-permissions"
+}
+export type ConnectNonTrialBillingPlan = BillingPlan.ConnectBasic | BillingPlan.ConnectPro | BillingPlan.ConnectEnterprise;

package/dist/src/utils/connect.d.ts

@@ -0,0 +1,13 @@
+import { NODE_ENV, PLATFORM_ENV } from '../types/environment';
+/**
+ * get asset url i.e. cdn public url or dashboard public url
+ * @param env
+ * @returns
+ */
+export declare const getAssetUrl: ({ CDN_PUBLIC_URL: cdnHost, DASHBOARD_PUBLIC_URL: dashboardPublicURL, VERSION: version, PLATFORM_ENV: platformEnv, NODE_ENV: nodeEnv, }: {
+    CDN_PUBLIC_URL: string;
+    DASHBOARD_PUBLIC_URL: string;
+    NODE_ENV: string;
+    PLATFORM_ENV: string;
+    VERSION: string;
+}) => string;

package/dist/src/utils/crypto.d.ts

@@ -0,0 +1,7 @@
+/**
+ * hashes a string
+ *
+ * @param {string} value
+ * @returns {string} 10 digit hash
+ */
+export declare function hash(value: string): string;

package/dist/src/utils/generic.d.ts

@@ -0,0 +1,30 @@
+/**
+ * a helper class for creating deferred promises
+ * @tutorial https://gist.github.com/GFoley83/5877f6c09fbcfd62569c51dc91444cf0
+ */
+export declare class DeferredPromise<T> implements Promise<T> {
+    [Symbol.toStringTag]: 'Promise';
+    private _promise;
+    private _resolve;
+    private _reject;
+    private _state;
+    get state(): 'pending' | 'fulfilled' | 'rejected';
+    constructor();
+    then<TResult1, TResult2>(onfulfilled?: (value: T) => TResult1 | PromiseLike<TResult1>, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): Promise<TResult1 | TResult2>;
+    catch<TResult>(onrejected?: (reason: any) => TResult | PromiseLike<TResult>): Promise<T | TResult>;
+    resolve(value?: T | PromiseLike<T>): void;
+    reject(reason?: any): void;
+    finally(onfinally?: () => void): Promise<T>;
+}
+/**
+ * given a type definition of a record and possible values for each key,
+ * it generates an array of every permutation
+ *
+ * @template T
+ * @param {{ [k in keyof T]: T[k][] }} input
+ * @returns {T[]}
+ */
+export declare function generateMatrix<T extends Record<string, any>>(input: {
+    [k in keyof T]: T[k][];
+}, limit?: number): T[];
+export declare function sleep(milliseconds: number): Promise<void>;

package/dist/src/utils/http.d.ts

@@ -0,0 +1,13 @@
+/**
+ * check if url is valid or not
+ * @param url
+ * @returns
+ */
+export declare const isValidUrl: (url: string) => boolean;
+/**
+ * it will add https protocol if protocol is not added in utl
+ * @param url
+ * @returns
+ */
+export declare function sanitizeUrl(url: string): string;
+export declare function getServiceUrl(service: string, domain: string): string;