Add Count

Author: Volo

README.md

@@ -746,6 +746,62 @@ const response = await client.conversations.redactConversationPart({
 });
 ```
 
+### Counts
+
+#### [App Total Count](https://developers.intercom.com/intercom-api-reference/reference/company-user-counts)
+
+```typescript
+const response = await client.counts.forApp();
+```
+
+#### [Conversation Count Model](https://developers.intercom.com/intercom-api-reference/reference/conversation-counts)
+
+```typescript
+const response = await client.counts.countConversation();
+```
+
+#### [Admin Conversation Count Model](https://developers.intercom.com/intercom-api-reference/reference/admin-conversations)
+
+```typescript
+const response = await client.counts.countAdminConversation();
+```
+
+#### [User Segment/Tag Count Model](https://developers.intercom.com/intercom-api-reference/reference/user-tag-counts)
+
+##### Count User Segment
+
+```typescript
+const response = await client.counts.countUserSegment();
+```
+
+##### Count User Tag
+
+```typescript
+const response = await client.counts.countUserTag();
+```
+
+#### [Company User/Segment/Tag Count Model](https://developers.intercom.com/intercom-api-reference/reference/company-tag-counts)
+
+##### Count Company Segment
+
+```typescript
+const response = await client.counts.countCompanySegment();
+const response = await client.counts.countCompanyTag();
+const response = await client.counts.countCompanyUser();
+```
+
+##### Count Company Tag
+
+```typescript
+const response = await client.counts.countCompanyTag();
+```
+
+##### Count Company User
+
+```typescript
+const response = await client.counts.countCompanyUser();
+```
+
 ### Data Attributes
 
 #### [Create Data Attribute](https://developers.intercom.com/intercom-api-reference/reference/create-data-attributes)

lib/client.ts

@@ -5,8 +5,9 @@ import { merge, omit } from 'lodash';
 import Article from './article';
 import Admin from './admin';
 import Company from './company';
-import Conversation from './conversation';
 import Contact from './contact';
+import Conversation from './conversation';
+import Count from './count';
 import DataAttribute from './dataAttribute';
 import Event from './event';
 import HelpCenter from './helpCenter';
@@ -56,6 +57,7 @@ export default class Client {
     companies: Company;
     contacts: Contact;
     conversations: Conversation;
+    counts: Count;
     dataAttributes: DataAttribute;
     events: Event;
     helpCenter: HelpCenter;
@@ -88,6 +90,7 @@ export default class Client {
         this.companies = new Company(this);
         this.contacts = new Contact(this);
         this.conversations = new Conversation(this);
+        this.counts = new Count(this);
         this.dataAttributes = new DataAttribute(this);
         this.events = new Event(this);
         this.helpCenter = new HelpCenter(this);

lib/count.ts

@@ -0,0 +1,86 @@
+import {
+    Client,
+    CompanySegmentCountResponse,
+    CompanyTagCountResponse,
+    CompanyUserCountResponse,
+    UserCountResponse,
+    UserSegmentCountResponse,
+    UserTagCountResponse,
+} from '.';
+import {
+    AdminConversationCountResponse,
+    AppTotalCountResponse,
+    CompanyCountResponse,
+    ConversationCountResponse,
+    CountEntity,
+    CountType,
+} from './count/count.types';
+
+export default class Count {
+    public readonly baseUrl = 'counts';
+
+    constructor(private readonly client: Client) {
+        this.client = client;
+    }
+
+    forApp() {
+        return this.client.get<AppTotalCountResponse>({
+            url: `/${this.baseUrl}`,
+        });
+    }
+
+    countCompany() {
+        return this.client.get<CompanyCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.COMPANY },
+        });
+    }
+    countCompanySegment() {
+        return this.client.get<CompanySegmentCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.COMPANY, count: CountEntity.SEGMENT },
+        });
+    }
+    countCompanyTag() {
+        return this.client.get<CompanyTagCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.COMPANY, count: CountEntity.TAG },
+        });
+    }
+    countCompanyUser() {
+        return this.client.get<CompanyUserCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.COMPANY, count: CountEntity.USER },
+        });
+    }
+    countConversation() {
+        return this.client.get<ConversationCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.CONVERSATION },
+        });
+    }
+    countAdminConversation() {
+        return this.client.get<AdminConversationCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.CONVERSATION, count: CountEntity.ADMIN },
+        });
+    }
+    countUser() {
+        return this.client.get<UserCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.USER },
+        });
+    }
+    countUserSegment() {
+        return this.client.get<UserSegmentCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.USER, count: CountEntity.SEGMENT },
+        });
+    }
+    countUserTag() {
+        return this.client.get<UserTagCountResponse>({
+            url: `/${this.baseUrl}`,
+            params: { type: CountType.USER, count: CountEntity.TAG },
+        });
+    }
+}

lib/count/count.types.ts

@@ -0,0 +1,90 @@
+export type AppTotalCountResponse = {
+    type: 'count.hash';
+    company: CountObject;
+    user: CountObject;
+    lead: CountObject;
+    tag: CountObject;
+    segment: CountObject;
+};
+
+export type ConversationCountResponse = {
+    type: 'count';
+    conversation: {
+        assigned: number;
+        closed: number;
+        open: number;
+        unassigned: number;
+    };
+};
+
+export type AdminConversationCountResponse = {
+    type: 'count';
+    conversation: {
+        admin: {
+            id: string;
+            name: string;
+            open: number;
+            closed: number;
+        }[];
+    };
+};
+
+export type CompanyCountResponse = {
+    type: 'count';
+    company: CountObject;
+};
+
+export type CompanySegmentCountResponse = {
+    type: 'count';
+    company: { segment: GenericCountObject[] };
+};
+
+export type CompanyTagCountResponse = {
+    type: 'count';
+    company: { tag: GenericCountObject[] };
+};
+
+export type CompanyUserCountResponse = {
+    type: 'count';
+    company: {
+        user: GenericCountObject & { remote_company_id: string }[];
+    };
+};
+
+export type UserCountResponse = {
+    type: 'count';
+    user: {
+        user: CountObject;
+    };
+};
+
+export type UserSegmentCountResponse = {
+    type: 'count';
+    company: { segment: GenericCountObject[] };
+};
+
+export type UserTagCountResponse = {
+    type: 'count';
+    company: { tag: GenericCountObject[] };
+};
+
+export type CountObject = {
+    count: number;
+};
+
+export enum CountType {
+    CONVERSATION = 'conversation',
+    USER = 'user',
+    COMPANY = 'company',
+}
+
+export enum CountEntity {
+    ADMIN = 'admin',
+    SEGMENT = 'segment',
+    TAG = 'tag',
+    USER = 'user',
+}
+
+type GenericCountObject = {
+    [title: string]: number;
+};

lib/index.ts

@@ -30,6 +30,7 @@ export * from './common/common.types';
 export * from './company/company.types';
 export * from './contact/contact.types';
 export * from './conversation/conversation.types';
+export * from './count/count.types';
 export * from './dataAttribute/dataAttribute.types';
 export * from './event/event.types';
 export * from './helpCenter/helpCenter.types';

test/counts.ts

@@ -0,0 +1,85 @@
+import assert from 'assert';
+import { Client, CountEntity, CountType } from '../lib';
+import nock from 'nock';
+
+describe.only('counts', () => {
+    const client = new Client({
+        usernameAuth: { username: 'foo', password: 'bar' },
+    });
+    it('gets total app count', async () => {
+        nock('https://api.intercom.io').get('/counts').reply(200, {});
+        const response = await client.counts.forApp();
+
+        assert.deepStrictEqual({}, response);
+    });
+    it('gets conversations count', async () => {
+        nock('https://api.intercom.io')
+            .get('/counts')
+            .query({ type: CountType.CONVERSATION })
+            .reply(200, {});
+        const response = await client.counts.countConversation();
+
+        assert.deepStrictEqual({}, response);
+    });
+    it('gets admin conversations count', async () => {
+        nock('https://api.intercom.io')
+            .get('/counts')
+            .query({ type: CountType.CONVERSATION, count: CountEntity.ADMIN })
+            .reply(200, {});
+        const response = await client.counts.countAdminConversation();
+
+        assert.deepStrictEqual({}, response);
+    });
+    describe('for user', () => {
+        it('gets segment count', async () => {
+            nock('https://api.intercom.io')
+                .get('/counts')
+                .query({ type: CountType.USER, count: CountEntity.SEGMENT })
+                .reply(200, {});
+            const response = await client.counts.countUserSegment();
+
+            assert.deepStrictEqual({}, response);
+        });
+
+        it('gets tags count', async () => {
+            nock('https://api.intercom.io')
+                .get('/counts')
+                .query({ type: CountType.USER, count: CountEntity.TAG })
+                .reply(200, {});
+            const response = await client.counts.countUserTag();
+
+            assert.deepStrictEqual({}, response);
+        });
+    });
+    describe('for company', () => {
+        it('gets segment count', async () => {
+            nock('https://api.intercom.io')
+                .get('/counts')
+                .query({ type: CountType.COMPANY, count: CountEntity.SEGMENT })
+                .reply(200, {});
+            const response = await client.counts.countCompanySegment();
+
+            assert.deepStrictEqual({}, response);
+        });
+
+        it('gets tags count', async () => {
+            nock('https://api.intercom.io')
+                .get('/counts')
+                .query({ type: CountType.COMPANY, count: CountEntity.TAG })
+                .reply(200, {});
+            const response = await client.counts.countCompanyTag();
+
+            assert.deepStrictEqual({}, response);
+        });
+
+        it('gets users count', async () => {
+            nock('https://api.intercom.io')
+                .get('/counts')
+                .query({ type: CountType.COMPANY, count: CountEntity.USER })
+                .reply(200, {});
+            const response = await client.counts.countCompanyUser();
+
+            assert.deepStrictEqual({}, response);
+        });
+    });
+});