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

package/build/client-Bk76ySik.js

@@ -0,0 +1,769 @@
+// source/encode.ts
+const encodeValue = (value) => {
+	if (value === null) return "";
+	if (value === true) return "1";
+	if (value === false) return "0";
+	if (value instanceof Date) return encodeURIComponent(value.toISOString());
+	return encodeURIComponent(String(value));
+};
+const pairs = (key, value) => {
+	if (value === void 0) return [];
+	if (Array.isArray(value)) return value.flatMap((item, index) => pairs(`${key}[${index}]`, item));
+	if (typeof value === "object" && value !== null && !(value instanceof Date)) return Object.entries(value).flatMap(([name, item]) => pairs(`${key}[${name}]`, item));
+	return [`${encodeURIComponent(key)}=${encodeValue(value)}`];
+};
+/**
+* Serializes params into a PHP style query string (`filter[>ID]=5&select[0]=ID`), the format Bitrix expects
+* for commands inside a `batch` call
+* @param params params of a single command
+*/
+const encode = (params) => Object.entries(params).flatMap(([key, value]) => pairs(key, value)).join("&");
+// source/errors.ts
+var BitrixError = class extends Error {
+	name = "BitrixError";
+	code;
+	description;
+	method;
+	status;
+	command;
+	constructor({ code, description, method, status, command, cause }) {
+		const target = command === void 0 ? method : `${method} (command ${command})`;
+		super(`${target}: ${[code, description].filter(Boolean).join(" ")}`, { cause });
+		this.code = code;
+		this.description = description;
+		this.method = method;
+		this.status = status;
+		this.command = command;
+	}
+};
+// source/transport.ts
+const RETRYABLE_CODES = /* @__PURE__ */ new Set([
+	"QUERY_LIMIT_EXCEEDED",
+	"OPERATION_TIME_LIMIT",
+	"INTERNAL_SERVER_ERROR"
+]);
+const sleep = (ms, signal) => new Promise((resolve, reject) => {
+	const onAbort = () => {
+		clearTimeout(timer);
+		reject(signal?.reason);
+	};
+	const timer = setTimeout(() => {
+		signal?.removeEventListener("abort", onAbort);
+		resolve();
+	}, ms);
+	signal?.addEventListener("abort", onAbort, { once: true });
+});
+/**
+* Time to wait before retrying an operating time limit error: until the limit resets when Bitrix said when,
+* exponential backoff otherwise
+* @param resetAt when the limit resets, in milliseconds since the epoch
+* @param delay base backoff delay in milliseconds
+* @param attempt zero based retry attempt
+*/
+const operatingDelay = (resetAt, delay, attempt) => resetAt !== void 0 && resetAt > Date.now() ? resetAt - Date.now() : delay * 2 ** attempt;
+const isRetryable = (error) => error instanceof BitrixError ? RETRYABLE_CODES.has(error.code) || error.status !== void 0 && error.status >= 500 : error instanceof TypeError;
+const parse = async (response, method) => {
+	const text = await response.text();
+	let body;
+	try {
+		body = JSON.parse(text);
+	} catch (cause) {
+		throw new BitrixError({
+			code: "INVALID_RESPONSE",
+			description: `expected JSON, received ${text.slice(0, 100)}`,
+			method,
+			status: response.status,
+			cause
+		});
+	}
+	if (!response.ok || "error" in body) throw new BitrixError({
+		code: typeof body["error"] === "string" && body["error"] !== "" ? body["error"] : `HTTP_${response.status}`,
+		description: typeof body["error_description"] === "string" ? body["error_description"] : response.statusText,
+		method,
+		status: response.status
+	});
+	return body;
+};
+/**
+* Sends a single REST method call as a JSON POST, applying auth, rate limiting and retries
+* @param options endpoint, auth, fetch and hook settings
+* @param limiter rate limiter every request waits for
+* @param retry how often and how long to wait before retrying
+* @param retry.retries attempts after the first one
+* @param retry.delay base backoff delay in milliseconds
+*/
+const createTransport = (options, limiter, { retries, delay }) => {
+	const { auth, onAuthExpired } = options;
+	const fetcher = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+	const base = new URL(options.url.endsWith("/") ? options.url : `${options.url}/`);
+	const operatingResetAt = /* @__PURE__ */ new Map();
+	let refreshing;
+	const refreshAuth = async () => {
+		refreshing ??= (async () => {
+			try {
+				await onAuthExpired?.();
+			} finally {
+				refreshing = void 0;
+			}
+		})();
+		await refreshing;
+	};
+	const request = async (method, params, signal) => {
+		const token = typeof auth === "function" ? await auth() : auth;
+		const response = await fetcher(new URL(method, base), {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				accept: "application/json"
+			},
+			body: JSON.stringify(token === void 0 ? params : {
+				...params,
+				auth: token
+			}),
+			...signal && { signal }
+		});
+		return parse(response, method);
+	};
+	const send = async (method, params, signal, attempt) => {
+		await limiter.acquire(signal);
+		options.onRequest?.({
+			method,
+			params,
+			attempt
+		});
+		const started = Date.now();
+		let envelope;
+		try {
+			envelope = await request(method, params, signal);
+		} catch (error) {
+			options.onResponse?.({
+				method,
+				attempt,
+				duration: Date.now() - started,
+				error
+			});
+			throw error;
+		}
+		options.onResponse?.({
+			method,
+			attempt,
+			duration: Date.now() - started,
+			...envelope.time && { time: envelope.time }
+		});
+		if (envelope.time?.operating_reset_at !== void 0) operatingResetAt.set(method, envelope.time.operating_reset_at * 1e3);
+		return envelope;
+	};
+	const backoff = (error, method, attempt) => {
+		if (error instanceof BitrixError && error.code === "QUERY_LIMIT_EXCEEDED") {
+			limiter.exhaust();
+			return 0;
+		}
+		if (error instanceof BitrixError && error.code === "OPERATION_TIME_LIMIT") return operatingDelay(operatingResetAt.get(method), delay, attempt);
+		return delay * 2 ** attempt;
+	};
+	return async (method, params = {}, callSignal) => {
+		const signals = [options.signal, callSignal].filter((signal) => signal !== void 0);
+		const signal = signals.length > 1 ? AbortSignal.any(signals) : signals[0];
+		let refreshed = false;
+		let sent = 0;
+		for (let attempt = 0;; attempt++) try {
+			return await send(method, params, signal, sent++);
+		} catch (error) {
+			if (signal?.aborted) throw signal.reason;
+			if (error instanceof BitrixError && error.code === "expired_token" && onAuthExpired && !refreshed) {
+				refreshed = true;
+				await refreshAuth();
+				attempt--;
+				continue;
+			}
+			if (attempt >= retries || !isRetryable(error)) throw error;
+			await sleep(backoff(error, method, attempt), signal);
+		}
+	};
+};
+const OPERATION_TIME_LIMIT = "OPERATION_TIME_LIMIT";
+const chunk = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, index) => items.slice(index * size, (index + 1) * size));
+const toCommand = ({ method, params }) => {
+	const query = params ? encode(params) : "";
+	return query === "" ? method : `${method}?${query}`;
+};
+/**
+* Runs any number of commands through `batch`, 50 per request. Keyed commands give keyed results,
+* arrays give arrays. A failed command lands in `errors` and does not reject the whole call.
+* Commands that hit the operating time limit are sent again once the limit resets, unless they
+* reference results of other commands with `$result`
+* @param transport sends the `batch` requests
+* @param retry how often and how long to wait before sending limited commands again
+* @param retry.retries attempts after the first one
+* @param retry.delay base backoff delay in milliseconds
+*/
+const createBatch = (transport, { retries, delay }) => {
+	const send = async (entries, { halt = false, signal }) => {
+		const cmd = Object.fromEntries(entries.map(([key, command]) => [key, toCommand(command)]));
+		const { result, time } = await transport("batch", {
+			halt: halt ? 1 : 0,
+			cmd
+		}, signal);
+		const methods = new Map(entries.map(([key, command]) => [key, command.method]));
+		const errors = Object.fromEntries(Object.entries(result.result_error).map(([key, raw]) => [key, new BitrixError({
+			code: raw.error || "COMMAND_FAILED",
+			description: raw.error_description ?? "",
+			method: methods.get(key) ?? "batch",
+			command: key
+		})]));
+		const resetAt = time?.operating_reset_at === void 0 ? void 0 : time.operating_reset_at * 1e3;
+		return {
+			results: { ...result.result },
+			errors,
+			resetAt
+		};
+	};
+	const retryable = (entries, { results, errors }, halt) => {
+		const limited = entries.filter(([key]) => errors[key]?.code === OPERATION_TIME_LIMIT);
+		if (limited.length === 0) return [];
+		const skipped = halt ? entries.filter(([key]) => !(key in results) && !(key in errors)) : [];
+		return [...limited, ...skipped].filter(([, command]) => !JSON.stringify(command.params ?? {}).includes("$result"));
+	};
+	const run = async (entries, options) => {
+		let response = await send(entries, options);
+		for (let attempt = 0; attempt < retries; attempt++) {
+			const again = retryable(entries, response, options.halt ?? false);
+			if (again.length === 0) break;
+			await sleep(operatingDelay(response.resetAt, delay, attempt), options.signal);
+			const retried = await send(again, options);
+			const keys = new Set(again.map(([key]) => key));
+			response = {
+				results: {
+					...response.results,
+					...retried.results
+				},
+				errors: {
+					...Object.fromEntries(Object.entries(response.errors).filter(([key]) => !keys.has(key))),
+					...retried.errors
+				},
+				resetAt: retried.resetAt
+			};
+		}
+		return response;
+	};
+	return (async (commands, options = {}) => {
+		const entries = Object.entries(commands);
+		const chunks = chunk(entries, 50);
+		const responses = [];
+		if (options.halt) for (const group of chunks) {
+			const response = await run(group, options);
+			responses.push(response);
+			if (Object.keys(response.errors).length > 0) break;
+		}
+		else responses.push(...await Promise.all(chunks.map((group) => run(group, options))));
+		const results = Object.assign({}, ...responses.map((response) => response.results));
+		const errors = Object.assign({}, ...responses.map((response) => response.errors));
+		return Array.isArray(commands) ? {
+			results: entries.map(([key]) => results[key]),
+			errors: entries.map(([key]) => errors[key])
+		} : {
+			results,
+			errors
+		};
+	});
+};
+// source/limiter.ts
+/**
+* Leaky bucket matching the Bitrix request limit: up to `burst` requests at once, then `refillPerSecond`.
+* Requests over the limit reserve a token in advance and wait until it refills
+* @param options bucket size and refill rate
+* @param options.burst requests allowed at once, 50 by default
+* @param options.refillPerSecond requests added back every second, 2 by default
+*/
+const createLimiter = ({ burst = 50, refillPerSecond = 2 } = {}) => {
+	let tokens = burst;
+	let updatedAt = Date.now();
+	const refill = () => {
+		const now = Date.now();
+		tokens = Math.min(burst, tokens + (now - updatedAt) / 1e3 * refillPerSecond);
+		updatedAt = now;
+	};
+	const acquire = async (signal) => {
+		signal?.throwIfAborted();
+		refill();
+		tokens -= 1;
+		if (tokens >= 0) return;
+		try {
+			await sleep(Math.ceil(-tokens / refillPerSecond * 1e3), signal);
+		} catch (error) {
+			tokens += 1;
+			throw error;
+		}
+	};
+	const exhaust = () => {
+		refill();
+		tokens = Math.min(tokens, 0);
+	};
+	return {
+		acquire,
+		exhaust
+	};
+};
+/**
+* Finds the rows in a list result: either the result itself or the single array a catalog style result wraps
+* @param method method name used in the error message
+* @param result result of a list method
+*/
+const unwrap = (method, result) => {
+	if (Array.isArray(result)) return {
+		rows: result,
+		key: void 0
+	};
+	const entries = typeof result === "object" && result !== null ? Object.entries(result) : [];
+	const [entry] = entries;
+	if (entries.length === 1 && entry && Array.isArray(entry[1])) return {
+		rows: entry[1],
+		key: entry[0]
+	};
+	throw new TypeError(`${method} did not return a list`);
+};
+/**
+* Batches start with one page and double up to 50, so a consumer that stops early wastes few requests
+* @param size pages in the previous batch
+*/
+const grow = (size) => Math.min(size * 2, 50);
+/**
+* Adds the fields pagination relies on to an explicit select. Wildcards and no select already include them
+* @param select select of the caller
+* @param fields fields to add
+*/
+const withFields = (select, fields) => select && !select.includes("*") ? [.../* @__PURE__ */ new Set([...select, ...fields])] : select;
+const createPaginate = (transport, batch) => {
+	const runBatch = async function* (method, pages, signal, resumable) {
+		const { results, errors } = await batch(pages.map((params) => ({
+			method,
+			params
+		})), signal && { signal });
+		for (const [index, error] of errors.entries()) {
+			if (error && resumable && index > 0 && error.code === "OPERATION_TIME_LIMIT") return;
+			if (error) throw error;
+			yield { rows: unwrap(method, results[index]).rows };
+		}
+	};
+	const cursor = async function* (method, params, idField, count, signal) {
+		if (Object.keys(params.order ?? {}).some((field) => field !== idField)) throw new TypeError(`cursor pagination orders by ${idField}, use { mode: 'offset' } for a custom order`);
+		const { start: _start, ...rest } = params;
+		const select = withFields(rest.select, [idField]);
+		const page = (filter) => ({
+			...rest,
+			...select && { select },
+			filter: {
+				...rest.filter,
+				...filter
+			},
+			order: { [idField]: "ASC" },
+			start: -1
+		});
+		const { start: _counted, ...counted } = page({});
+		const first = await transport(method, count ? counted : page({}), signal);
+		let { rows, key } = unwrap(method, first.result);
+		yield {
+			rows,
+			total: count ? first.total : void 0
+		};
+		for (let size = 1; rows.length === 50; size = grow(size)) {
+			const lastId = rows.at(-1)[idField];
+			const pages = Array.from({ length: size }, (_, index) => page({ [`>${idField}`]: index === 0 ? lastId : `$result[${index - 1}]${key ? `[${key}]` : ""}[49][${idField}]` }));
+			for await ({rows} of runBatch(method, pages, signal, true)) {
+				yield { rows };
+				if (rows.length < 50) return;
+			}
+		}
+	};
+	const modified = async function* (method, params, idField, modifiedField, since, count, signal) {
+		if (Object.keys(params.order ?? {}).some((field) => field !== modifiedField && field !== idField)) throw new TypeError(`modified pagination orders by ${modifiedField} and ${idField}`);
+		const { start: _start, order: _order, ...rest } = params;
+		const select = withFields(rest.select, [idField, modifiedField]);
+		let after = { [`>=${modifiedField}`]: since instanceof Date ? since.toISOString() : since };
+		for (let counting = count;; counting = false) {
+			const page = await transport(method, {
+				...rest,
+				...select && { select },
+				filter: {
+					...rest.filter,
+					...after
+				},
+				order: {
+					[modifiedField]: "ASC",
+					[idField]: "ASC"
+				},
+				...!counting && { start: -1 }
+			}, signal);
+			const { rows } = unwrap(method, page.result);
+			yield {
+				rows,
+				total: counting ? page.total : void 0
+			};
+			if (rows.length < 50) return;
+			const last = rows.at(-1);
+			yield* cursor(method, {
+				...rest,
+				...select && { select },
+				filter: {
+					...rest.filter,
+					[`=${modifiedField}`]: last[modifiedField],
+					[`>${idField}`]: last[idField]
+				}
+			}, idField, false, signal);
+			after = { [`>${modifiedField}`]: last[modifiedField] };
+		}
+	};
+	const offset = async function* (method, params, signal) {
+		const first = await transport(method, {
+			...params,
+			start: params.start ?? 0
+		}, signal);
+		yield {
+			rows: unwrap(method, first.result).rows,
+			total: first.total
+		};
+		if (first.next === void 0) return;
+		const starts = [];
+		for (let start = first.next; start < (first.total ?? 0); start += 50) starts.push(start);
+		for (let index = 0, size = 1; index < starts.length; index += size, size = grow(size)) {
+			const pages = starts.slice(index, index + size).map((start) => ({
+				...params,
+				start
+			}));
+			yield* runBatch(method, pages, signal, false);
+		}
+	};
+	const pages = (method, params, options) => {
+		const { idField = "ID", signal, onProgress } = options;
+		const count = onProgress !== void 0;
+		if (options.mode === "modified") return modified(method, params, idField, options.modifiedField ?? "DATE_MODIFY", options.since, count, signal);
+		return options.mode === "offset" ? offset(method, params, signal) : cursor(method, params, idField, count, signal);
+	};
+	return async function* (method, params = {}, options = {}) {
+		let read = 0;
+		let total;
+		for await (const page of pages(method, params, options)) {
+			read += page.rows.length;
+			total ??= page.total;
+			options.onProgress?.({
+				read,
+				...total !== void 0 && { total }
+			});
+			yield* page.rows;
+		}
+	};
+};
+// source/services/crm.ts
+/**
+* CRM entities share one set of `crm.<entity>.*` methods, so their services only differ by name
+* @param core client methods the service is built on
+* @param core.call calls a single REST method
+* @param core.batch runs many commands in as few requests as possible
+* @param core.list reads every page of a list method
+* @param core.paginate iterates over every page of a list method
+* @param name entity name in the method names, like `deal` in `crm.deal.get`
+*/
+const createCrmService = ({ call, batch, list, paginate }, name) => {
+	const send = call;
+	const sendMany = batch;
+	const method = `crm.${name}`;
+	const modifiedField = name === "activity" ? "LAST_UPDATED" : "DATE_MODIFY";
+	return {
+		fields: () => send(`${method}.fields`),
+		get: (id) => send(`${method}.get`, { id }),
+		list: (params, options) => list(`${method}.list`, params, options),
+		paginate: (params, options) => paginate(`${method}.list`, params, options),
+		changedSince: (since, params, options) => paginate(`${method}.list`, params, {
+			...options,
+			mode: "modified",
+			since,
+			modifiedField
+		}),
+		create: (fields, params) => send(`${method}.add`, {
+			fields,
+			...params && { params }
+		}),
+		update: (id, fields, params) => send(`${method}.update`, {
+			id,
+			fields,
+			...params && { params }
+		}),
+		delete: (id) => send(`${method}.delete`, { id }),
+		createMany: (items, params) => sendMany(items.map((fields) => ({
+			method: `${method}.add`,
+			params: {
+				fields,
+				...params && { params }
+			}
+		}))),
+		updateMany: (items, params) => sendMany(items.map(({ id, fields }) => ({
+			method: `${method}.update`,
+			params: {
+				id,
+				fields,
+				...params && { params }
+			}
+		}))),
+		deleteMany: (ids) => sendMany(ids.map((id) => ({
+			method: `${method}.delete`,
+			params: { id }
+		})))
+	};
+};
+/**
+* Product rows of a deal or lead
+* @param core client methods the service is built on
+* @param core.call calls a single REST method
+* @param name entity name in the method names
+*/
+const createProductRows = ({ call }, name) => ({
+	get: (id) => call(`crm.${name}.productrows.get`, { id }),
+	set: (id, rows) => call(`crm.${name}.productrows.set`, {
+		id,
+		rows
+	})
+});
+/**
+* Links between CRM entities through `crm.<owner>.<linked>.*`, like the contacts of a deal
+* @param core client methods the service is built on
+* @param core.call calls a single REST method
+* @param owner entity the links belong to
+* @param linked entity that is linked
+*/
+const createLinks = ({ call }, owner, linked) => {
+	const send = call;
+	const method = `crm.${owner}.${linked}`;
+	const key = `${linked.toUpperCase()}_ID`;
+	return {
+		get: (id) => send(`${method}.items.get`, { id }),
+		set: (id, links) => send(`${method}.items.set`, {
+			id,
+			items: links
+		}),
+		add: (id, link) => send(`${method}.add`, {
+			id,
+			fields: link
+		}),
+		delete: (id, linkedId) => send(`${method}.delete`, {
+			id,
+			fields: { [key]: linkedId }
+		}),
+		clear: (id) => send(`${method}.items.delete`, { id })
+	};
+};
+// source/services/currencies.ts
+/**
+* Currencies are identified by their code like `USD`, and `crm.currency.list` returns every currency at once
+* @param core client methods the service is built on
+* @param core.call calls a single REST method
+*/
+const createCurrenciesService = ({ call }) => ({
+	fields: () => call("crm.currency.fields"),
+	get: (id) => call("crm.currency.get", { id }),
+	list: (params = {}) => call("crm.currency.list", params),
+	create: (fields) => call("crm.currency.add", { fields }),
+	update: (id, fields) => call("crm.currency.update", {
+		id,
+		fields
+	}),
+	delete: (id) => call("crm.currency.delete", { id }),
+	base: () => call("crm.currency.base.get"),
+	setBase: (id) => call("crm.currency.base.set", { id })
+});
+// source/services/items.ts
+/**
+* `crm.item.*` works for every CRM type by its `entityTypeId`, smart processes included, and wraps its results
+* in `item`, `items` or `fields`
+* @param core client methods the service is built on
+* @param core.call calls a single REST method
+* @param core.list reads every page of a list method
+* @param core.paginate iterates over every page of a list method
+* @param entityTypeId type id, like 2 for deals or the id of a smart process from `crm.type.list`
+*/
+const createItemsService = ({ call, list, paginate }, entityTypeId) => ({
+	fields: async () => (await call("crm.item.fields", { entityTypeId })).fields,
+	get: async (id) => (await call("crm.item.get", {
+		entityTypeId,
+		id
+	})).item,
+	list: (params = {}, options = {}) => list("crm.item.list", {
+		...params,
+		entityTypeId
+	}, {
+		...options,
+		idField: "id"
+	}),
+	paginate: (params = {}, options = {}) => paginate("crm.item.list", {
+		...params,
+		entityTypeId
+	}, {
+		...options,
+		idField: "id"
+	}),
+	changedSince: (since, params = {}, options = {}) => paginate("crm.item.list", {
+		...params,
+		entityTypeId
+	}, {
+		...options,
+		mode: "modified",
+		since,
+		idField: "id",
+		modifiedField: "updatedTime"
+	}),
+	create: async (fields) => (await call("crm.item.add", {
+		entityTypeId,
+		fields
+	})).item,
+	update: async (id, fields) => (await call("crm.item.update", {
+		entityTypeId,
+		id,
+		fields
+	})).item,
+	delete: async (id) => {
+		await call("crm.item.delete", {
+			entityTypeId,
+			id
+		});
+	}
+});
+// source/services/products.ts
+/**
+* `catalog.product.list` rejects requests that do not select `id` and `iblockId`
+* @param params list params from the caller
+*/
+const withRequiredSelect = (params) => ({
+	...params,
+	select: [.../* @__PURE__ */ new Set([
+		...params.select ?? ["name"],
+		"id",
+		"iblockId"
+	])]
+});
+const createProductsService = ({ call, list, paginate }) => ({
+	fields: async (iblockId) => (await call("catalog.product.getFieldsByFilter", { filter: { iblockId } })).product,
+	get: async (id) => (await call("catalog.product.get", { id })).product,
+	list: (params, options = {}) => list("catalog.product.list", withRequiredSelect(params), {
+		...options,
+		idField: "id"
+	}),
+	paginate: (params, options = {}) => paginate("catalog.product.list", withRequiredSelect(params), {
+		...options,
+		idField: "id"
+	}),
+	create: async (fields) => (await call("catalog.product.add", { fields })).element,
+	update: async (id, fields) => (await call("catalog.product.update", {
+		id,
+		fields
+	})).element,
+	delete: (id) => call("catalog.product.delete", { id })
+});
+// source/services/statuses.ts
+/**
+* `crm.status.list` returns every status at once, so there is no pagination here
+* @param core client methods the service is built on
+* @param core.call calls a single REST method
+*/
+const createStatusesService = ({ call }) => ({
+	fields: () => call("crm.status.fields"),
+	get: (id) => call("crm.status.get", { id }),
+	list: (params = {}) => call("crm.status.list", params),
+	create: (fields) => call("crm.status.add", { fields }),
+	update: (id, fields) => call("crm.status.update", {
+		id,
+		fields
+	}),
+	delete: (id, { forced = false } = {}) => call("crm.status.delete", {
+		id,
+		params: { FORCED: forced ? "Y" : "N" }
+	})
+});
+// source/services/users.ts
+/**
+* `user.get` takes `sort` and `order` as plain strings instead of an order map, so users paginate by offset
+* @param core client methods the service is built on
+* @param core.call calls a single REST method
+* @param core.list reads every page of a list method
+* @param core.paginate iterates over every page of a list method
+*/
+const createUsersService = ({ call, list, paginate }) => ({
+	fields: () => call("user.fields"),
+	current: () => call("user.current"),
+	get: async (id) => {
+		const [user] = await call("user.get", { ID: id });
+		if (!user) throw new BitrixError({
+			code: "NOT_FOUND",
+			description: `user ${id} not found`,
+			method: "user.get"
+		});
+		return user;
+	},
+	list: (params = {}, options = {}) => list("user.get", params, {
+		...options,
+		mode: "offset"
+	}),
+	paginate: (params = {}, options = {}) => paginate("user.get", params, {
+		...options,
+		mode: "offset"
+	})
+});
+// source/client.ts
+/**
+* Creates a Bitrix24 REST client
+* @param options endpoint, auth, limiter and retry settings
+* @example
+* const bitrix = createClient({ url: 'https://portal.bitrix24.com/rest/1/WEBHOOK_TOKEN' })
+* const deal = await bitrix.deals.get(77)
+*/
+const createClient = (options) => {
+	const retry = {
+		retries: 3,
+		delay: 1e3,
+		...options.retry
+	};
+	const transport = createTransport(options, createLimiter(options.limiter), retry);
+	const call = (async (method, params, { raw = false, signal } = {}) => {
+		const envelope = await transport(method, params, signal);
+		return raw ? envelope : envelope.result;
+	});
+	const batch = createBatch(transport, retry);
+	const paginate = createPaginate(transport, batch);
+	const list = (async (method, params, listOptions) => {
+		const rows = [];
+		for await (const row of paginate(method, params, listOptions)) rows.push(row);
+		return rows;
+	});
+	const core = {
+		call,
+		batch,
+		paginate,
+		list
+	};
+	return {
+		...core,
+		activities: createCrmService(core, "activity"),
+		companies: {
+			...createCrmService(core, "company"),
+			contacts: createLinks(core, "company", "contact")
+		},
+		contacts: {
+			...createCrmService(core, "contact"),
+			companies: createLinks(core, "contact", "company")
+		},
+		currencies: createCurrenciesService(core),
+		deals: {
+			...createCrmService(core, "deal"),
+			productRows: createProductRows(core, "deal"),
+			contacts: createLinks(core, "deal", "contact")
+		},
+		items: (entityTypeId) => createItemsService(core, entityTypeId),
+		leads: {
+			...createCrmService(core, "lead"),
+			productRows: createProductRows(core, "lead"),
+			contacts: createLinks(core, "lead", "contact")
+		},
+		products: createProductsService(core),
+		statuses: createStatusesService(core),
+		users: createUsersService(core)
+	};
+};
+export { BitrixError as n, createClient as t };