@2bad/bitrix 2.5.1 → 3.0.0-beta.0

package/README.md

@@ -5,8 +5,7 @@
 [![NPM version](https://img.shields.io/npm/v/@2bad/bitrix)](https://www.npmjs.com/package/@2bad/bitrix)
 [![License](https://img.shields.io/npm/l/@2bad/bitrix)](https://www.npmjs.com/package/@2bad/bitrix)
 [![Code coverage](https://img.shields.io/codecov/c/github/2BAD/bitrix)](https://codecov.io/gh/2BAD/bitrix)
-[![Travis Build Status](https://img.shields.io/travis/2BAD/bitrix?logo=Travis)](https://travis-ci.org/github/2BAD/bitrix)
-[![GitHub Build Status](https://img.shields.io/github/workflow/status/2BAD/bitrix/Integration%20testing?logo=GitHub)](https://github.com/2BAD/bitrix/actions?query=workflow%3A%22Integration+testing%22)
+[![GitHub Build Status](https://img.shields.io/github/actions/workflow/status/2BAD/bitrix/build.yml)](https://github.com/2BAD/bitrix/actions/workflows/build.yml)
 [![Written in TypeScript](https://img.shields.io/github/languages/top/2BAD/bitrix)](https://github.com/2BAD/bitrix/search?l=typescript)
 
 - 🔥 No bullshit

package/build/bitrix.d.ts

@@ -0,0 +1,65 @@
+import { ExtendOptions } from 'got';
+/**
+ * Construct a Bitrix client with generic methods
+ * @param restURI REST endpoint, like a `https://hello.bitrix24.ua/rest` or an inbound webhook endpoint,
+ *                like a `https://hello.bitrix24.ua/rest/1/WEBHOOK_TOKEN`.
+ * @param accessToken Bitrix application Access Token. Do not specify in case inbound webhook endpoint used.
+ * @param clientOptions an object that will overwrite underlying configuration for HTTP client,
+ *                see `https://github.com/sindresorhus/got/blob/main/documentation/2-options.md`.
+ */
+export declare const Bitrix: (restURI: string, accessToken?: string, clientOptions?: ExtendOptions) => {
+    call: import("./client/methods/call.ts").Call;
+    batch: import("./client/methods/batch.ts").Batch;
+    list: import("./client/methods/list.ts").List;
+    companies: {
+        fields: () => Promise<import("./payloads.ts").GetPayload<import("./services/common.js").Fields>>;
+        create: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_COMPANY_ADD>>(fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<number>>;
+        get: (id: string) => Promise<import("./payloads.ts").GetPayload<import("./services/companies/entities.js").Company>>;
+        list: (params?: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_COMPANY_LIST>) => Promise<import("./payloads.ts").ListPayload<import("./services/companies/entities.js").Company>>;
+        update: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_COMPANY_UPDATE>>(id: string, fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<boolean>>;
+    };
+    contacts: {
+        fields: () => Promise<import("./payloads.ts").GetPayload<import("./services/common.js").Fields>>;
+        create: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_CONTACT_ADD>>(fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<number>>;
+        get: (id: string) => Promise<import("./payloads.ts").GetPayload<import("./services/contacts/entities.js").Contact>>;
+        list: (params?: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_CONTACT_LIST>) => Promise<import("./payloads.ts").ListPayload<import("./services/contacts/entities.js").Contact>>;
+        update: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_CONTACT_UPDATE>>(id: string, fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<boolean>>;
+    };
+    deals: {
+        fields: () => Promise<import("./payloads.ts").GetPayload<import("./services/common.js").Fields>>;
+        create: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_DEAL_ADD>>(fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<number>>;
+        get: (id: string) => Promise<import("./payloads.ts").GetPayload<import("./services/deals/entities.js").Deal>>;
+        list: (params?: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_DEAL_LIST>) => Promise<import("./payloads.ts").ListPayload<import("./services/deals/entities.js").Deal>>;
+        update: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_DEAL_UPDATE>>(id: string, fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<boolean>>;
+    };
+    leads: {
+        fields: () => Promise<import("./payloads.ts").GetPayload<import("./services/common.js").Fields>>;
+        create: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_LEAD_ADD>>(fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<number>>;
+        get: (id: string) => Promise<import("./payloads.ts").GetPayload<import("./services/leads/entities.js").Lead>>;
+        list: (params?: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_LEAD_LIST>) => Promise<import("./payloads.ts").ListPayload<import("./services/leads/entities.js").Lead>>;
+        update: <D extends import("./methods.js").MethodParams<import("./methods.js").Method.CRM_LEAD_UPDATE>>(id: string, fields: D["fields"], params?: D["params"]) => Promise<import("./payloads.ts").GetPayload<boolean>>;
+    };
+    statuses: {
+        fields: () => Promise<import("./payloads.ts").GetPayload<import("./services/common.js").Fields>>;
+        create: (fields: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_STATUS_ADD>["fields"]) => Promise<import("./payloads.ts").GetPayload<number>>;
+        delete: (id: string | number, params?: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_STATUS_DELETE>["params"]) => Promise<import("./payloads.ts").GetPayload<boolean>>;
+        get: (id: string | number) => Promise<import("./payloads.ts").GetPayload<import("./services/statuses/entities.js").Status>>;
+        list: (params?: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_STATUS_LIST>) => Promise<import("./payloads.ts").ListPayload<import("./services/statuses/entities.js").Status>>;
+        update: (id: string | number, fields: import("./methods.js").MethodParams<import("./methods.js").Method.CRM_STATUS_UPDATE>["fields"]) => Promise<import("./payloads.ts").GetPayload<boolean>>;
+    };
+    users: {
+        fields: () => Promise<import("./payloads.ts").GetPayload<import("./services/users/entities.js").User>>;
+        get: (id?: string) => Promise<import("./payloads.ts").GetPayload<readonly import("./services/users/entities.js").User[]>>;
+    };
+};
+export default Bitrix;
+export * from './methods.js';
+export * from './commands.js';
+export * from './services/common.js';
+export * from './services/companies/entities.js';
+export * from './services/contacts/entities.js';
+export * from './services/currencies/entities.js';
+export * from './services/deals/entities.js';
+export * from './services/leads/entities.js';
+export * from './services/statuses/entities.js';
+export * from './services/users/entities.js';

package/build/bitrix.js

@@ -0,0 +1,55 @@
+import Client from "./client/index.js";
+import CompaniesService from "./services/companies/index.js";
+import ContactsService from "./services/contacts/index.js";
+import DealsService from "./services/deals/index.js";
+import LeadsService from "./services/leads/index.js";
+import StatusesService from "./services/statuses/index.js";
+import UsersService from "./services/users/index.js";
+/**
+ * Construct a Bitrix client with generic methods
+ * @param restURI REST endpoint, like a `https://hello.bitrix24.ua/rest` or an inbound webhook endpoint,
+ *                like a `https://hello.bitrix24.ua/rest/1/WEBHOOK_TOKEN`.
+ * @param accessToken Bitrix application Access Token. Do not specify in case inbound webhook endpoint used.
+ * @param clientOptions an object that will overwrite underlying configuration for HTTP client,
+ *                see `https://github.com/sindresorhus/got/blob/main/documentation/2-options.md`.
+ */ export const Bitrix = (restURI, accessToken, clientOptions)=>{
+    const { call, batch, list } = Client(restURI, accessToken, clientOptions);
+    return {
+        call,
+        batch,
+        list,
+        companies: CompaniesService({
+            call,
+            list
+        }),
+        contacts: ContactsService({
+            call,
+            list
+        }),
+        deals: DealsService({
+            call,
+            list
+        }),
+        leads: LeadsService({
+            call,
+            list
+        }),
+        statuses: StatusesService({
+            call
+        }),
+        users: UsersService({
+            call
+        })
+    };
+};
+export default Bitrix;
+export * from "./methods.js";
+export * from "./commands.js";
+export * from "./services/common.js";
+export * from "./services/companies/entities.js";
+export * from "./services/contacts/entities.js";
+export * from "./services/currencies/entities.js";
+export * from "./services/deals/entities.js";
+export * from "./services/leads/entities.js";
+export * from "./services/statuses/entities.js";
+export * from "./services/users/entities.js";

package/build/client/hooks/addAccessToken.js

@@ -0,0 +1,9 @@
+/**
+ * Got can't merge `query` option with other queries if they are string. But that hook can.
+ */ export default ((accessToken)=>(options)=>{
+        if (!accessToken) return;
+        if (!options.url) return;
+        if (typeof options.url.search === 'string') {
+            options.url.search = `${options.url.search}${options.url.search ? '&' : '?'}access_token=${accessToken}`;
+        }
+    });

package/build/{module/client → client}/index.d.ts

@@ -8,8 +8,8 @@ import { ExtendOptions } from 'got';
  *                see `https://github.com/sindresorhus/got/blob/main/documentation/2-options.md`.
  */
 declare const _default: (restURI: string, accessToken?: string, options?: ExtendOptions) => {
-    call: import("./methods/call").Call;
-    batch: import("./methods/batch").Batch;
-    list: import("./methods/list").List;
+    call: import("./methods/call.js").Call;
+    batch: import("./methods/batch.js").Batch;
+    list: import("./methods/list.js").List;
 };
 export default _default;

package/build/{module/client → client}/index.js

@@ -1,11 +1,12 @@
-import got from 'got';
-import Queue from 'p-queue';
-import addAccessToken from './hooks/addAccessToken';
-import Batch from './methods/batch';
-import Call from './methods/call';
-import List from './methods/list';
+import got from "got";
+import Queue from "p-queue";
+import addAccessToken from "./hooks/addAccessToken.js";
+import Batch from "./methods/batch.js";
+import Call from "./methods/call.js";
+import List from "./methods/list.js";
 const BITRIX_API_RATE_LIMIT = 2;
-const BITRIX_API_RATE_INTERVAL = 1000; // 1 second
+const BITRIX_API_RATE_INTERVAL = 1000 // 1 second
+;
 /**
  * Construct a Bitrix client with generic methods
  * @param restURI REST endpoint, like a `https://hello.bitrix24.ru/rest` or an inbound webhook endpoint,
@@ -13,8 +14,7 @@ const BITRIX_API_RATE_INTERVAL = 1000; // 1 second
  * @param accessToken Bitrix application Access Token. Do not specify in case inbound webhook endpoint used.
  * @param options an object that will overwrite underlying configuration for HTTP client,
  *                see `https://github.com/sindresorhus/got/blob/main/documentation/2-options.md`.
- */
-export default (restURI, accessToken, options) => {
+ */ export default ((restURI, accessToken, options)=>{
     const client = got.extend({
         prefixUrl: restURI,
         headers: {
@@ -32,17 +32,22 @@ export default (restURI, accessToken, options) => {
         intervalCap: BITRIX_API_RATE_LIMIT,
         interval: BITRIX_API_RATE_INTERVAL
     });
-    const queuedGet = (...args) => queue.add(() => client.get(...args));
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    const queuedGet = (...args)=>queue.add(()=>client.get(...args));
     // @ts-expect-error @todo remove after issue is resolved (https://github.com/sindresorhus/got/issues/954)
-    const call = Call({ get: queuedGet });
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    const call = Call({
+        get: queuedGet
+    });
     // @ts-expect-error @todo remove after issue is resolved (https://github.com/sindresorhus/got/issues/954)
-    const batch = Batch({ get: queuedGet });
-    const list = List({ call, batch });
+    const batch = Batch({
+        get: queuedGet
+    });
+    const list = List({
+        call,
+        batch
+    });
     return {
         call,
         batch,
         list
     };
-};
+});

package/build/{module/client → client}/methods/batch.d.ts

@@ -1,7 +1,7 @@
 import got from 'got';
-import { Commands } from '../../commands';
-import { Method, MethodPayloadType } from '../../methods';
-import { BatchPayload } from '../../payloads';
+import { Commands } from '../../commands.js';
+import { Method, MethodPayloadType } from '../../methods.js';
+import { BatchPayload } from '../../payloads.js';
 export declare const MAX_COMMANDS_PER_BATCH = 50;
 /**
  * Split any number of commands into the chunks with max commands per batch in each chunk
@@ -18,15 +18,15 @@ export declare const prepareCommandsQueries: <C extends Commands, R = { [K in ke
  * @todo Generics inference is complicated here and might be not super accurate
  */
 export declare const mergeBatchPayloads: <B extends BatchPayload<unknown>, P = B extends BatchPayload<infer U> ? U : never>(payloads: readonly B[]) => BatchPayload<P>;
-export declare type CommandsPayloads<C extends Commands, CM = {
+export type CommandsPayloads<C extends Commands, CM = {
     [K in keyof C]: C[K] extends {
         readonly method: infer M;
     } ? M : never;
 }> = {
     [K in keyof CM]: MethodPayloadType<CM[K] extends Method ? CM[K] : never>;
 };
-export declare type Batch = <C extends Commands, P = CommandsPayloads<C>>(commands: C, commandsPerRequest?: number) => Promise<BatchPayload<P>>;
-declare type Dependencies = {
+export type Batch = <C extends Commands, P = CommandsPayloads<C>>(commands: C, commandsPerRequest?: number) => Promise<BatchPayload<P>>;
+type Dependencies = {
     readonly get: typeof got.get;
 };
 /**

package/build/client/methods/batch.js

@@ -0,0 +1,75 @@
+import chunk from "lodash.chunk";
+import fromPairs from "lodash.frompairs";
+import { stringify as toQuery } from "qs";
+import { Method } from "../../methods.js";
+import isArray from "../../utils/isArray.js";
+import { handlePayload } from "./call.js";
+export const MAX_COMMANDS_PER_BATCH = 50;
+/**
+ * Split any number of commands into the chunks with max commands per batch in each chunk
+ */ export const chunkCommands = (commands, size = MAX_COMMANDS_PER_BATCH)=>{
+    const commandsIsArray = isArray(commands);
+    const chunks = chunk(Object.entries(commands), size);
+    // @todo Generated return type isn't very accurate since it says that it will make array of <C>, while
+    //       in fact <C> will be distributed among chunks. That gives wrong hints with named commands and arrays as const.
+    return chunks.map((c)=>commandsIsArray ? c.map(([_key, command])=>command) : fromPairs(c));
+};
+/**
+ * Prepares list of commands to be used in requests to the Bitrix
+ * @note We could avoid that function... if only Bitrix API would support posting of the batch commands as
+ *       plain objects, like it does with other methods. Instead, it should be a dict or array of string queries
+ */ export const prepareCommandsQueries = (commands)=>Object.entries(commands).reduce((calls, [name, { method, params }])=>{
+        const stringifiedParams = params ? `?${toQuery(params)}` : '';
+        return {
+            ...calls,
+            [`cmd[${name}]`]: `${method}${stringifiedParams}`
+        };
+    // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
+    }, {});
+/**
+ * Merges list of batch responses into a single batch
+ * @todo Generics inference is complicated here and might be not super accurate
+ */ export const mergeBatchPayloads = (payloads)=>{
+    const merge = (a, b)=>isArray(a) && isArray(b) ? [
+            ...a,
+            ...b
+        ] : {
+            ...a,
+            ...b
+        };
+    return payloads.reduce((merged, payload)=>({
+            result: {
+                result: merge(merged.result.result || [], payload.result.result),
+                result_error: merge(merged.result.result_error || [], payload.result.result_error),
+                result_next: merge(merged.result.result_next || [], payload.result.result_next),
+                result_time: merge(merged.result.result_time || [], payload.result.result_time),
+                result_total: merge(merged.result.result_total || [], payload.result.result_total)
+            },
+            time: {
+                ...merged.time,
+                ...payload.time
+            }
+        }), {
+        result: {},
+        time: {}
+    });
+};
+/**
+ * Dispatches a batch request with specified commands. Will fill figure out payload type based on the Methods.
+ * Supports unlimited number of commands. If they do exceed max amount of commands per batch, will dispatch
+ * multiple request and merge result into single batch payload
+ * @todo For now due to issues with types it won't check `params` of command, so any Method can be used
+ *       with any (even wrong) params
+ */ export default (({ get })=>{
+    const batch = async (commands, commandsPerRequest = MAX_COMMANDS_PER_BATCH)=>{
+        const call = (c)=>get(Method.BATCH, {
+                searchParams: prepareCommandsQueries(c)
+            }).then(({ body })=>body);
+        const calls = chunkCommands(commands, commandsPerRequest).map(call);
+        return await Promise.all(calls).then((chunkedPayloads)=>{
+            const payloads = mergeBatchPayloads(chunkedPayloads);
+            return handlePayload(payloads);
+        });
+    };
+    return batch;
+});

package/build/{module/client → client}/methods/call.d.ts

@@ -1,13 +1,13 @@
 import got from 'got';
-import { Method, MethodParams, MethodPayload } from '../../methods';
-import { Payload } from '../../payloads';
+import { Method, MethodParams, MethodPayload } from '../../methods.js';
+import { Payload } from '../../payloads.js';
 /**
  * Checks wether payload have any errors and if it does — throws them
  * Bitrix payload types do not provide discriminators, so we're forced to type cast them
  */
 export declare const handlePayload: <P extends Payload<unknown>>(payload: P) => P;
-export declare type Call = <M extends Method>(method: M, params: MethodParams<M>) => Promise<MethodPayload<M>>;
-declare type Dependencies = {
+export type Call = <M extends Method>(method: M, params: MethodParams<M>) => Promise<MethodPayload<M>>;
+type Dependencies = {
     readonly get: typeof got.get;
 };
 /**

package/build/{module/client → client}/methods/call.js

@@ -1,10 +1,9 @@
-import { stringify as toQuery } from 'qs';
-import isArray from '../../utils/isArray';
+import { stringify as toQuery } from "qs";
+import isArray from "../../utils/isArray.js";
 /**
  * Checks wether payload have any errors and if it does — throws them
  * Bitrix payload types do not provide discriminators, so we're forced to type cast them
- */
-export const handlePayload = (payload) => {
+ */ export const handlePayload = (payload)=>{
     if (payload.error) {
         throw new Error(`[call] failed to get the resource: ${payload.error ?? ''}.`);
     }
@@ -20,9 +19,9 @@ export const handlePayload = (payload) => {
 };
 /**
  * Dispatches a request with specified method and params. Will fill figure out payload type based on the Method
- */
-export default ({ get }) => {
-    const call = (method, params) => get(method, { searchParams: toQuery(params) })
-        .then(({ body }) => handlePayload(body));
+ */ export default (({ get })=>{
+    const call = (method, params)=>get(method, {
+            searchParams: toQuery(params)
+        }).then(({ body })=>handlePayload(body));
     return call;
-};
+});

package/build/{module/client → client}/methods/list.d.ts

@@ -1,15 +1,15 @@
-import { Command } from '../../commands';
-import { ListableMethod, MethodParams, MethodPayloadType } from '../../methods';
-import { BatchPayload, ListPayload } from '../../payloads';
-import { Batch } from './batch';
-import { Call } from './call';
+import { Command } from '../../commands.js';
+import { ListableMethod, MethodParams, MethodPayloadType } from '../../methods.js';
+import { BatchPayload, ListPayload } from '../../payloads.js';
+import { Batch } from './batch.js';
+import { Call } from './call.js';
 /**
  * Generates required amount of commands to process specified amount of entries
  */
-export declare const fillWithCommands: <C extends Command>({ method, params }: C, start: number, toProcess: number, entriesPerCommand: number) => readonly {
+export declare const fillWithCommands: <C extends Command>({ method, params }: C, start: number, toProcess: number, entriesPerCommand: number) => ReadonlyArray<{
     readonly method: C["method"];
-    readonly params?: C["params"] | undefined;
-}[];
+    readonly params?: C["params"];
+}>;
 /**
  * Get the highest value from object or an array if there's any
  */
@@ -18,11 +18,11 @@ export declare const highest: (input: ReadonlyArray<number | undefined> | Record
  * Converts batch payload to a list payload
  */
 export declare const batchToListPayload: <P>(payload: BatchPayload<Record<string, P> | readonly P[]>) => ListPayload<P>;
-declare type Dependencies = {
+type Dependencies = {
     readonly call: Call;
     readonly batch: Batch;
 };
-export declare type List = <M extends ListableMethod>(method: M, params: MethodParams<M>) => Promise<ListPayload<MethodPayloadType<M>>>;
+export type List = <M extends ListableMethod>(method: M, params: MethodParams<M>) => Promise<ListPayload<MethodPayloadType<M>>>;
 /**
  * Gets all entries by dispatching required amount of requests. Will fill figure out payload type based on the Method.
  */

package/build/client/methods/list.js

@@ -0,0 +1,58 @@
+import range from "lodash.range";
+const MAX_ENTRIES_PER_COMMAND = 50;
+/**
+ * Generates required amount of commands to process specified amount of entries
+ */ export const fillWithCommands = ({ method, params }, start, toProcess, entriesPerCommand)=>{
+    const requiresCommands = Math.ceil((toProcess - start) / entriesPerCommand);
+    return range(0, requiresCommands).map((i)=>({
+            method,
+            params: {
+                ...params,
+                start: start + entriesPerCommand * i
+            }
+        }));
+};
+/**
+ * Get the highest value from object or an array if there's any
+ */ export const highest = (input)=>Object.values(input).reduce((a, b)=>a !== undefined && b !== undefined ? a > b ? a : b : a !== undefined && b === undefined ? a : a === undefined && b !== undefined ? b : undefined, undefined);
+/**
+ * Converts batch payload to a list payload
+ */ export const batchToListPayload = (payload)=>{
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    const { result: { result, result_total, result_error, result_next }, time } = payload;
+    const flattenResult = Object.entries(result).reduce(// @ts-expect-error ignore this for now
+    (flatten, [_key, r])=>!r ? flatten : [
+            ...flatten,
+            ...r
+        ], []);
+    return {
+        error: Object.values(result_error).join('\n'),
+        next: highest(result_next),
+        result: flattenResult,
+        // @todo Not accurate, we do not care
+        time,
+        total: highest(result_total) ?? 0
+    };
+};
+/**
+ * Gets all entries by dispatching required amount of requests. Will fill figure out payload type based on the Method.
+ */ export default (({ call, batch })=>{
+    const list = async (method, params)=>{
+        const start = params.start ?? 0;
+        const listAll = async ()=>{
+            const batchCommands = fillWithCommands({
+                method,
+                params
+            }, start, firstCall.total, MAX_ENTRIES_PER_COMMAND);
+            const payload = await batch(batchCommands);
+            // @ts-expect-error ignore this for now
+            return batchToListPayload(payload);
+        };
+        const firstCall = await call(method, {
+            ...params,
+            start
+        });
+        return !firstCall.next ? firstCall : await listAll();
+    };
+    return list;
+});

package/build/{module/commands.d.ts → commands.d.ts}

@@ -1,9 +1,9 @@
-import { Method } from './methods';
-export declare type Command = {
+import { Method } from './methods.js';
+export type Command = {
     readonly method: Method;
     readonly params?: Record<string, any>;
 };
-export declare type Commands = {
+export type Commands = {
     readonly [key: string]: Command;
 } | {
     readonly [index: number]: Command;

package/build/commands.js

@@ -0,0 +1 @@
+export { };

package/build/{module/methods.d.ts → methods.d.ts}

@@ -1,13 +1,13 @@
-import { Commands } from './commands';
-import { BatchPayload } from './payloads';
-import { CompaniesMethods } from './services/companies/methods';
-import { ContactsMethods } from './services/contacts/methods';
-import { DealsMethods } from './services/deals/methods';
-import { LeadsMethods } from './services/leads/methods';
-import { StatusesMethods } from './services/statuses/methods';
-import { UsersMethods } from './services/users/methods';
-import { Diff } from './utils/Diff';
-import { ExtractValue } from './utils/ExtractValue';
+import { Commands } from './commands.js';
+import { BatchPayload } from './payloads.js';
+import { CompaniesMethods } from './services/companies/methods.js';
+import { ContactsMethods } from './services/contacts/methods.js';
+import { DealsMethods } from './services/deals/methods.js';
+import { LeadsMethods } from './services/leads/methods.js';
+import { StatusesMethods } from './services/statuses/methods.js';
+import { UsersMethods } from './services/users/methods.js';
+import { Diff } from './utils/Diff.js';
+import { ExtractValue } from './utils/ExtractValue.js';
 export declare enum Method {
     BATCH = "batch",
     CRM_COMPANY_FIELDS = "crm.company.fields",
@@ -40,16 +40,16 @@ export declare enum Method {
     USER_GET = "user.get"
 }
 declare const LISTABLE_METHODS: readonly [Method.CRM_COMPANY_LIST, Method.CRM_CONTACT_LIST, Method.CRM_DEAL_LIST, Method.CRM_LEAD_LIST];
-export declare type ListableMethod = typeof LISTABLE_METHODS[number];
-export declare type GettableMethod = Diff<Method, ListableMethod>;
-declare type MethodsMap = {
+export type ListableMethod = typeof LISTABLE_METHODS[number];
+export type GettableMethod = Diff<Method, ListableMethod>;
+type MethodsMap = {
     readonly [key: string]: {
         readonly type: unknown;
         readonly payload: unknown;
         readonly params: Record<string, unknown>;
     };
 };
-export declare type ListParams = {
+export type ListParams = {
     readonly start?: number;
     readonly order?: {
         readonly [key: string]: string;
@@ -66,7 +66,7 @@ export declare type ListParams = {
  * - `payload` — a payload that method returns
  * - `params` — params that method accepts
  */
-export declare type Methods = MethodsMap & CompaniesMethods & ContactsMethods & DealsMethods & LeadsMethods & StatusesMethods & UsersMethods & {
+export type Methods = MethodsMap & CompaniesMethods & ContactsMethods & DealsMethods & LeadsMethods & StatusesMethods & UsersMethods & {
     readonly [Method.BATCH]: {
         readonly type: unknown;
         readonly payload: BatchPayload<unknown>;
@@ -76,17 +76,17 @@ export declare type Methods = MethodsMap & CompaniesMethods & ContactsMethods &
 /**
  * Retrieve specified method data
  */
-export declare type MethodData<M extends Method> = ExtractValue<Methods, M>;
+export type MethodData<M extends Method> = ExtractValue<Methods, M>;
 /**
  * Retrieve associated with specified method type
  */
-export declare type MethodPayloadType<M extends Method> = MethodData<M>['type'];
+export type MethodPayloadType<M extends Method> = MethodData<M>['type'];
 /**
  * Retrieve specified method payload type
  */
-export declare type MethodPayload<M extends Method> = MethodData<M>['payload'];
+export type MethodPayload<M extends Method> = MethodData<M>['payload'];
 /**
  * Retrieve specified method params
  */
-export declare type MethodParams<M extends Method> = MethodData<M>['params'];
+export type MethodParams<M extends Method> = MethodData<M>['params'];
 export {};

package/build/{module/methods.js → methods.js}

@@ -1,5 +1,5 @@
 export var Method;
-(function (Method) {
+(function(Method) {
     Method["BATCH"] = "batch";
     Method["CRM_COMPANY_FIELDS"] = "crm.company.fields";
     Method["CRM_COMPANY_ADD"] = "crm.company.add";
@@ -31,8 +31,8 @@ export var Method;
     Method["USER_GET"] = "user.get";
 })(Method || (Method = {}));
 const LISTABLE_METHODS = [
-    Method.CRM_COMPANY_LIST,
-    Method.CRM_CONTACT_LIST,
-    Method.CRM_DEAL_LIST,
-    Method.CRM_LEAD_LIST
+    "crm.company.list",
+    "crm.contact.list",
+    "crm.deal.list",
+    "crm.lead.list"
 ];

package/build/{main/payloads.d.ts → payloads.d.ts}

@@ -1,4 +1,4 @@
-export declare type PayloadTime = {
+export type PayloadTime = {
     readonly start: number;
     readonly finish: number;
     readonly duration: number;
@@ -6,18 +6,18 @@ export declare type PayloadTime = {
     readonly date_start: string;
     readonly date_finish: string;
 };
-export declare type GetPayload<P> = {
+export type GetPayload<P> = {
     readonly result: P;
     readonly time: PayloadTime;
 };
-export declare type ListPayload<P> = {
+export type ListPayload<P> = {
     readonly result: readonly P[];
     readonly error?: string;
     readonly total: number;
     readonly next?: number;
     readonly time: PayloadTime;
 };
-export declare type BatchPayload<C> = {
+export type BatchPayload<C> = {
     readonly result: {
         readonly result: {
             readonly [P in keyof C]?: C[P];
@@ -37,4 +37,4 @@ export declare type BatchPayload<C> = {
     };
     readonly time: PayloadTime;
 };
-export declare type Payload<P> = GetPayload<P> | ListPayload<P> | BatchPayload<P>;
+export type Payload<P> = GetPayload<P> | ListPayload<P> | BatchPayload<P>;

package/build/payloads.js

@@ -0,0 +1 @@
+export { };