@whitewall/blip-sdk 0.0.136 → 0.0.137

package/src/types/envelope.ts

@@ -0,0 +1,9 @@
+import type { NodeLike } from './node.ts'
+
+export type Envelope = {
+    id: string
+    from?: NodeLike
+    to?: NodeLike
+    metadata?: Record<string, string | null>
+    pp?: NodeLike
+}

package/src/types/flow.ts

@@ -0,0 +1,327 @@
+import type { MessageTypesContent } from './message.ts'
+
+type SendMessageActionSettings = {
+    $invalid?: boolean
+    id: string
+    type: keyof MessageTypesContent
+    content: MessageTypesContent[keyof MessageTypesContent]
+}
+
+type ProcessHttpActionSettings = {
+    $invalid?: boolean
+    method: 'POST' | 'GET' | 'PUT' | 'DELETE'
+    // The URL to be called, you can use variables in the URL, for example: https://api.example.com/{{contact.email}}
+    uri: string
+    // The headers to be sent in the request. You can use variables in the headers, for example: Authorization: Bearer {{config.token}}
+    headers: Record<string, string>
+    // The body of the request. You can use variables in the body, for example: { "email": "{{contact.email}}" }
+    body: string
+    responseBodyVariable: string
+    responseStatusVariable: string
+}
+
+type TrackEventActionSettings = {
+    $invalid?: boolean
+    category: string
+    action: string
+    extras: Record<string, string>
+}
+
+type MergeContactActionSettings = {
+    $invalid?: boolean
+    name: string
+    email: string
+    city: string
+    extras: Record<string, string>
+}
+
+type ExecuteScriptActionSettings = {
+    $invalid?: boolean
+    function: 'run'
+    // It should be a valid ES5 code
+    source: string
+    // The input variables that will be passed to the function, you must not use the {{ variableName }} syntax or @ syntax here, just the variable name
+    // Can be a context variable or any other special variable
+    inputVariables: Array<string>
+    // The context variable name to store the returned result of the function
+    outputVariable: string
+}
+
+type SendRawMessageActionSettings = {
+    $invalid?: boolean
+    type: 'application/json'
+    // Useful to send raw content to the user, like raw whatsapp messages
+    // Example: {"recipient_type": "individual","type": "interactive","interactive": {"type": "button","body": {"text": "..."},"action": {"buttons": [...]}}}
+    rawContent: string
+}
+
+type SetVariableActionSettings = {
+    $invalid?: boolean
+    variable: string
+    value: string
+    // Expiration time of the variable in seconds, if unsure, don't set it
+    expiration?: number
+}
+
+type TypeOfStateId = 'state' | 'variable'
+
+export type Condition = {
+    source: 'input' | 'context'
+    // The variable name of the conversation context to be evaluated, if the 'source' value is 'context'
+    variable?: string
+    // The type of the comparison. Optional. The default value is 'equals'
+    comparison:
+        | 'equals'
+        | 'notEquals'
+        | 'contains'
+        | 'startsWith'
+        | 'endsWith'
+        | 'greaterThan'
+        | 'lessThan'
+        | 'greaterThanOrEquals'
+        | 'lessThanOrEquals'
+        | 'matches'
+        | 'approximateTo'
+        | 'exists'
+        | 'notExists'
+    // The operator for comparison with the provided values. The default value is 'or'
+    operator?: 'or' | 'and'
+    values: Array<string>
+}
+
+export type Action = {
+    $id: string
+    // The type of content should only exists if the action is of type SendMessage or SendRawMessage
+    // It should match the content type of the action settings
+    $typeOfContent?: // if don`t exists is set with empty string in GET
+        | ''
+        // type = text/plain
+        | 'text'
+        // type = application/vnd.lime.select+json
+        // content.scope = immediate
+        | 'select-immediate'
+        // content.scope = persistent
+        | 'select'
+        // type = application/vnd.lime.media-link+json
+        // content.type = image/png, image/jpeg, image/gif
+        | 'media'
+        // content.type = audio/mpeg, audio/wav, audio/ogg
+        | 'media-audio'
+        // content.type = video/mp4
+        | 'media-video'
+        // content.type = application/pdf
+        | 'media-document'
+        // type = application/vnd.lime.chatstate+json
+        | 'chat-state'
+        // type = application/vnd.lime.web-link+json
+        | 'web-link'
+        // type = application/json
+        // Should be used only for SendRawMessage action
+        | 'raw-content'
+    // The type of the action to be executed
+    type: // Send a message to the user
+        | 'SendMessage'
+        // Send a raw message to the user, useful to send whatsapp content
+        | 'SendRawMessage'
+        // Track an event in the conversation
+        | 'TrackEvent'
+        // Process an HTTP request
+        | 'ProcessHttp'
+        // Update the contact information of the user
+        | 'MergeContact'
+        // Execute a ES5 script
+        | 'ExecuteScript'
+        // Set a variable in the context
+        | 'SetVariable'
+        | 'ForwardToDesk'
+        | 'LeavingFromDesk'
+    $title?: string
+    $invalid?: boolean
+    // The matching settings of the action type
+    settings:
+        | SendMessageActionSettings
+        | SendRawMessageActionSettings
+        | TrackEventActionSettings
+        | ProcessHttpActionSettings
+        | MergeContactActionSettings
+        | ExecuteScriptActionSettings
+        | SetVariableActionSettings
+        | Record<string, never>
+    // Must always be set if the action is of type SendMessage or SendRawMessage
+    // If other action type, it must be null
+    $cardContent?: {
+        document: {
+            id: string
+            // Should always be the same of settings.type
+            type: keyof MessageTypesContent | 'application/json'
+            // The content of the message, it should be the same of settings.content
+            content: MessageTypesContent[keyof MessageTypesContent] | string
+            textContent?: string
+        }
+        editable: boolean
+        deletable: boolean
+        position: 'left'
+    }
+    conditions?: Array<Condition>
+}
+
+type InputState = {
+    // Always same values, except for the document.id
+    $cardContent: {
+        document: {
+            id: string
+            type: 'text/plain'
+            content?: 'Entrada do usuário'
+            // Should always be the same of the variable name
+            textContent?: string
+        }
+        editable: boolean
+        editing: boolean
+        deletable: boolean
+        position: 'right'
+    }
+    $invalid: boolean
+    bypass: boolean
+    validation?: {
+        // Gets or sets the validation rule to be used
+        rule: 'text' | 'number' | 'date' | 'regex' | 'type'
+        // The regular expression to be used in case of the 'rule' value is regex'
+        regex?: string
+        // The type to be used in case of the 'rule' value is 'type'
+        type?: string
+        // The error message text to be returned to the user in case of the input value is not valid accordingly to the defined rule
+        error: string
+    }
+    // Input expiration time in minutes. If not set, the input will never expire. If unsure, don't set it
+    expiration?: string
+    variable?: string
+    conditions?: Array<Condition>
+}
+
+export type State = {
+    $contentActions: Array<{
+        // The actions that would be executed after entering actions
+        // All the actions here should be of type SendMessage
+        // This is the only place that can have the SendMessage action
+        action?: Action
+        // If the state should have a user input, it should be defined here
+        input?: InputState
+    }>
+    $conditionOutputs: Array<{
+        stateId: string
+        typeOfStateId?: TypeOfStateId
+        $id?: string
+        conditions: Array<Condition>
+        $invalid?: boolean
+        $isDeskOutput?: boolean
+        $isDeskDefaultOutput?: boolean
+    }>
+    // The actions that would be executed after entering the state
+    $enteringCustomActions: Array<Action>
+    // The actions that would be executed after leaving the state, before the output conditions
+    $leavingCustomActions: Array<Action>
+    $inputSuggestions: []
+    $defaultOutput: {
+        // Id of the state to redirect
+        stateId: string
+        $invalid: boolean
+        typeOfStateId?: TypeOfStateId
+    }
+    isAiGenerated?: boolean
+    deskStateVersion?: string
+    $afterStateChangedActions?: Array<Action>
+    $tags: Array<{
+        id: string
+        label: string
+        // Hexadecimal color code of the tag, with # prefix
+        background: string
+        canChangeBackground: boolean
+    }>
+    id?: string
+    // Only the special state with id "onbarding" has root as boolean
+    root?: boolean
+    $title?: string
+    $position?: {
+        top: string
+        left: string
+    }
+    $invalidContentActions: boolean
+    $invalidOutputs: boolean
+    $invalidCustomActions: boolean
+    $invalid?: boolean
+}
+
+export type BuilderConfiguration = {
+    'builder:minimumIntentScore'?: string
+    'builder:stateTrack'?: string
+    'builder:#localTimeZone'?: string
+} & Record<string, string | number>
+
+export type BuilderFlow = Record<'onboarding' | 'fallback' | string, State>
+
+// The history index is a number from 1 to 10, representing the last 10 publications
+export type HistoryIndex = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10
+
+export type Publication = {
+    authorIdentity: string
+    author: string
+}
+
+export type BuilderLatestPublications = {
+    // The last publication its a rotate of 10
+    lastInsertedIndex: HistoryIndex
+    isMoreOptionsActive: string
+    publications: Array<Publication & { publishedAt: string; index: HistoryIndex }>
+}
+
+export type BuilderLatestPublication = {
+    flow: BuilderFlow
+    globalActions?: State
+    configuration?: BuilderConfiguration
+}
+
+type RecursivelyRemoveDollar<T> = T extends object
+    ? T extends Array<infer U>
+        ? Array<RecursivelyRemoveDollar<U>>
+        : { [K in keyof T as K extends `$${string}` ? never : K]: RecursivelyRemoveDollar<T[K]> }
+    : T
+
+export type StateApplication = {
+    id: string
+    root?: boolean
+    name: string
+    inputActions: RecursivelyRemoveDollar<Array<Action>>
+    input: RecursivelyRemoveDollar<InputState>
+    outputActions: RecursivelyRemoveDollar<Array<Action>>
+    afterStateChangedActions: RecursivelyRemoveDollar<Array<Action>>
+    outputs: Array<{
+        stateId: string
+        conditions?: RecursivelyRemoveDollar<Array<Condition>>
+    }>
+}
+
+export type ApplicationAction = RecursivelyRemoveDollar<Action>
+
+export type ApplicationFlow = {
+    identifier: string
+    messageReceivers: Array<{
+        state: string
+        type: string
+    }>
+    notificationReceivers: Array<{
+        type: string
+    }>
+    serviceProviderType: string
+    settings: {
+        flow: {
+            id: string
+            version: number
+            states: Array<StateApplication>
+            configuration: BuilderConfiguration
+            inputActions: Array<ApplicationAction>
+            outputActions: Array<ApplicationAction>
+            type: 'flow'
+        }
+    }
+    settingsType: 'Settings'
+}

package/src/types/index.ts

@@ -0,0 +1,13 @@
+export * from './node.ts'
+export * from './envelope.ts'
+export * from './message.ts'
+export * from './command.ts'
+export * from './notification.ts'
+export * from './desk.ts'
+export * from './account.ts'
+export * from './whatsapp.ts'
+export * from './portal.ts'
+export * from './plugins.ts'
+export * from './analytics.ts'
+export * from './flow.ts'
+export * from './commons.ts'

package/src/types/message.ts

@@ -0,0 +1,116 @@
+import type { JsonObject } from './commons.ts'
+import type { TicketStatus } from './desk.ts'
+import type { Envelope } from './envelope.ts'
+import type { Identity } from './node.ts'
+
+export type PlainText = string
+
+export type Ticket<Type extends MessageTypes | undefined = undefined> = {
+    id: string
+    sequentialId: string
+    ownerIdentity: Identity
+    customerIdentity: Identity
+    customerDomain: string
+    provider: string
+    status: TicketStatus
+    statusDate?: string
+    storageDate: string
+    openDate?: string
+    closeDate?: string
+    firstResponseDate?: string
+    averageAgentResponseTime?: number
+    agentIdentity?: Identity
+    team?: string
+    rating: number
+    unreadMessages: number
+    customerInput: Type extends MessageTypes ? Document<Type> : undefined
+    closed: boolean
+    closedBy?: Identity
+    tags: Array<string>
+}
+
+export type Redirect<Type extends MessageTypes> = {
+    address: Identity
+    context: Document<Type>
+}
+
+export type MediaLink = {
+    // Mime type of the content
+    type: string
+    uri: string
+    title?: string
+    text?: string
+}
+
+export type Reply<Type extends MessageTypes> = {
+    replied: Document<Type>
+}
+
+export type Select = {
+    text: string
+    scope?: 'immediate' | 'persistent'
+    options: Array<{
+        text: string
+    }>
+}
+
+export type ChatState = {
+    state: 'starting' | 'composing' | 'paused' | 'deleted' | 'gone'
+}
+
+export type WebLink = {
+    title?: string
+    text: string
+    target?: 'blank' | 'self' | 'selfCompact' | 'selfTall'
+    uri: string
+}
+
+export interface MessageTypesContent {
+    'text/plain': PlainText
+    'application/vnd.iris.ticket+json': Ticket<MessageTypes>
+    'application/vnd.lime.redirect+json': Redirect<MessageTypes>
+    'application/vnd.lime.media-link+json': MediaLink
+    'application/json': JsonObject
+    'application/vnd.lime.reply+json': Reply<MessageTypes>
+    'application/vnd.lime.select+json': Select
+    'application/vnd.lime.chatstate+json': ChatState
+    'application/vnd.lime.web-link+json': WebLink
+}
+
+export type MessageTypes = keyof MessageTypesContent
+
+export type Document<Type extends MessageTypes> = {
+    type: Type
+    value: MessageTypesContent[Type]
+}
+
+export type MessageContent<Type extends MessageTypes> = {
+    type: Type
+    content: MessageTypesContent[Type]
+}
+
+export type Message<Type extends MessageTypes> = Envelope & MessageContent<Type>
+
+export type UnknownDocument = Document<MessageTypes>
+export type UnknownMessage = Message<MessageTypes>
+export type UnknownMessageContent = MessageContent<MessageTypes>
+
+export const isMessage = (envelope: Envelope): envelope is UnknownMessage =>
+    'type' in envelope && 'content' in envelope && typeof envelope.type === 'string'
+
+export const isMessageOfType = <Type extends MessageTypes>(
+    message: UnknownMessage,
+    type: Type,
+): message is Message<Type> => message.type === type
+
+export const isDocumentOfType = <Type extends MessageTypes>(
+    document: UnknownDocument,
+    type: Type,
+): document is Document<Type> => document.type === type
+
+export const messageToDocument = <Type extends MessageTypes>(
+    message: Pick<Message<Type>, 'type' | 'content'>,
+): Document<Type> => ({
+    type: message.type,
+    value: message.content,
+})

package/src/types/node.ts

@@ -0,0 +1,86 @@
+export type Domain = `${string}.${string}`
+export type BlipDomain = 'msging.net' | 'blip.ai' | '0mn.io'
+export type Identity = `${string}@${Domain}`
+export type NodeShape = Identity | `${Identity}/${string}`
+export type NodeLike = Node | NodeShape
+export type PossiblyNode = Node | string
+
+export class Node extends String {
+    constructor(
+        public readonly name: string,
+        public readonly domain: Domain,
+        public readonly instance?: string,
+    ) {
+        super(`${encodeURIComponent(name)}@${domain}${instance ? `/${instance}` : ''}`)
+    }
+
+    public toIdentity(): Identity {
+        return `${encodeURIComponent(this.name)}@${this.domain}`
+    }
+
+    public withInstance(instance: string) {
+        return new Node(this.name, this.domain, instance)
+    }
+
+    public getSource() {
+        switch (this.domain) {
+            case '0mn.io':
+                return 'Blip Chat'
+            case 'messenger.gw.msging.net':
+                return 'Messenger'
+            case 'instagram.gw.msging.net':
+                return 'Instagram'
+            case 'wa.gw.msging.net':
+                return 'WhatsApp'
+            case 'businessmessages.gw.msging.net':
+                return 'Google Business Messages'
+            case 'telegram.gw.msging.net':
+                return 'Telegram'
+            case 'workplace.gw.msging.net':
+                return 'Workplace'
+            case 'mailgun.gw.msging.net':
+                return 'Email'
+            case 'msging.net':
+                return 'Bot'
+            case 'blip.ai':
+                return 'Blip'
+            case 'tunnel.msging.net':
+                return 'Tunnel'
+            case 'custom.gw.msging.net': {
+                if (this.name.endsWith('.mail')) {
+                    return 'Email'
+                } else if (this.name.endsWith('.slack')) {
+                    return 'Slack'
+                } else {
+                    return 'Custom'
+                }
+            }
+            default:
+                return 'Unknown'
+        }
+    }
+
+    public static from(node: NodeLike): Node
+    public static from(nameOrPossibleNode: PossiblyNode, domain: Domain): Node
+    public static from(nameOrPossibleNode: PossiblyNode, domain?: Domain): Node {
+        if (nameOrPossibleNode instanceof Node) {
+            return nameOrPossibleNode
+        }
+
+        if (Node.isValid(nameOrPossibleNode)) {
+            const [name, otherPart] = nameOrPossibleNode.split('@')
+            const [domain, instance] = otherPart.split('/')
+            return new Node(decodeURIComponent(name), domain as Domain, instance)
+        }
+
+        if (domain) {
+            return new Node(decodeURIComponent(nameOrPossibleNode), domain)
+        }
+
+        throw new Error(`Invalid node shape: ${nameOrPossibleNode}`)
+    }
+
+    public static isValid(node: string | null | undefined): node is NodeShape {
+        return node ? /^.+@.+\..+/.test(node) : false
+    }
+}

package/src/types/notification.ts

@@ -0,0 +1,18 @@
+import type { Envelope } from './envelope.ts'
+import type { Reason } from './reason.ts'
+
+export type FailedNotification = {
+    event: 'failed'
+    reason: Reason
+}
+
+export type CommonNotification = {
+    // The official documentation is not up to date, so we need to check the source code
+    // https://github.com/takenet/lime-csharp/blob/master/src/Lime.Protocol/Notification.cs#L47
+    event: 'accepted' | 'consumed' | 'dispatched' | 'received' | 'deleted'
+}
+
+export type Notification = Envelope & (FailedNotification | CommonNotification)
+
+export const isNotification = (envelope: Envelope): envelope is Notification =>
+    'event' in envelope && typeof envelope.event === 'string'

package/src/types/plugins.ts

@@ -0,0 +1,51 @@
+export type Plugin = {
+    id: string
+    name: string
+    overview: string
+    price: number
+    isPaid: boolean
+    icon: string
+    storageDate: string
+    author: {
+        id: number
+        name: string
+        email: string
+        logo: string
+        isActive: boolean
+    }
+    installedBotsNumber?: number
+    installedBotsNumberAllContracts?: number
+    subscription?: {
+        status: string
+    }
+    tags: Array<string>
+    chargeType: string
+    imageUrl: string
+}
+
+export type DetailedPlugin = Plugin & {
+    description?: string
+    documentation?: string
+}
+
+export type PluginBilling = {
+    billingId: string
+    currency: string
+    description: string
+    featuresIncluded: string
+    isRecommended: boolean
+    language: string
+    name: string
+    price: number
+}
+
+export type PluginSubscription = DetailedPlugin & {
+    /** All possible billings for the plugin */
+    billings: Array<PluginBilling>
+    subscription: NonNullable<Plugin['subscription']> & {
+        /** The active billing plans, usually the length is 0 or 1 */
+        billings: Array<PluginBilling>
+        chargeType: string
+        price: number
+    }
+}

package/src/types/portal.ts

@@ -0,0 +1,39 @@
+import type { Identity } from './node.ts'
+
+export type Application = {
+    shortName: string
+    name: string
+    imageUri: string
+    template: 'builder' | 'master'
+    tenantId: string
+    created: string
+    updated: string
+    hasPermission: boolean
+    emailOwner: string
+}
+
+export type TenantSubscription = {
+    ownerIdentity: Identity
+    id: string
+    subscriber: Identity
+    planId: string
+    startDate: string
+    lastChangeDate: string
+    isPending: boolean
+    isActive: boolean
+    extras: {
+        WalletId: string
+    }
+}
+
+export type TenantUserInfo = {
+    tenantId: string
+    userIdentity: Identity
+    fullName: string
+    creationDate: string
+    updateDate: string
+    userStatus: string
+    roleId: 'member' | 'admin' | 'guest'
+}
+
+export type ApplicationUserInfo = { userIdentity: Identity; creationDate: string }

package/src/types/reason.ts

@@ -0,0 +1,22 @@
+export enum ReasonCodes {
+    PipelineTimeout = 2,
+    MaxThroughputExceeded = 38,
+    GeneralError = 101,
+    FailedToSendEnvelopeViaHTTP = 2105,
+}
+
+export interface Reason {
+    code: ReasonCodes | number
+    description: string
+}
+
+export const isReason = (value: unknown): value is Reason => {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        'code' in value &&
+        typeof value.code === 'number' &&
+        'description' in value &&
+        typeof value.description === 'string'
+    )
+}