icq-bot-sdk
Version:
ICQ New Bot Node.js SDK
1,620 lines (1,381 loc) • 92.4 kB
JavaScript
module.exports =
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 5);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ (function(module, exports) {
module.exports = require("query-string");
/***/ }),
/* 1 */
/***/ (function(module, __webpack_exports__, __webpack_require__) {
"use strict";
__webpack_require__.r(__webpack_exports__);
/* WEBPACK VAR INJECTION */(function(process, fetch) {/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ApiError", function() { return ApiError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ClientCodeError", function() { return ClientCodeError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RequestValidationError", function() { return RequestValidationError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ResponseValidationError", function() { return ResponseValidationError; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "self_get", function() { return self_get; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_sendText", function() { return messages_sendText; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_sendFile", function() { return messages_sendFile; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_uploadAndSendFile", function() { return messages_uploadAndSendFile; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_sendVoice", function() { return messages_sendVoice; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_uploadAndSendVoice", function() { return messages_uploadAndSendVoice; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_editText", function() { return messages_editText; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_deleteMessages", function() { return messages_deleteMessages; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "messages_answerCallbackQuery", function() { return messages_answerCallbackQuery; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_sendActions", function() { return chats_sendActions; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_getInfo", function() { return chats_getInfo; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_getAdmins", function() { return chats_getAdmins; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_getMembers", function() { return chats_getMembers; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_getBlockedUsers", function() { return chats_getBlockedUsers; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_getPendingUsers", function() { return chats_getPendingUsers; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_blockUser", function() { return chats_blockUser; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_unblockUser", function() { return chats_unblockUser; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_resolvePending", function() { return chats_resolvePending; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_setTitle", function() { return chats_setTitle; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_setAbout", function() { return chats_setAbout; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_setRules", function() { return chats_setRules; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_pinMessage", function() { return chats_pinMessage; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "chats_unpinMessage", function() { return chats_unpinMessage; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "files_getInfo", function() { return files_getInfo; });
/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "events_get", function() { return events_get; });
/* harmony import */ var ajv__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(4);
/* harmony import */ var ajv__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(ajv__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var query_string__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(0);
/* harmony import */ var query_string__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(query_string__WEBPACK_IMPORTED_MODULE_1__);
/* harmony import */ var object_to_formdata__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(2);
/* harmony import */ var object_to_formdata__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(object_to_formdata__WEBPACK_IMPORTED_MODULE_2__);
const ajv = new ajv__WEBPACK_IMPORTED_MODULE_0___default.a({
strict: false,
formats: {
int32: true,
int64: true,
float: true,
double: true,
binary: true,
byte: true,
password: true,
},
});
class ApiError extends Error {
constructor({ status, statusText, response, message, headers }) {
super(message);
this.status = status;
this.response = response;
this.statusText = statusText;
this.headers = headers;
}
}
class ClientCodeError extends Error {}
class RequestValidationError extends Error {
constructor({ message, element, method, errors = [] }) {
super(message);
this.element = element;
this.method = method;
this.errors = errors;
}
}
class ResponseValidationError extends Error {
constructor({ message, method, errors = [] }) {
super(message);
this.method = method;
this.errors = errors;
}
}
const defaultConfig = {
baseUrl: process.env.API_BASE_URL || 'https://__API_URL__',
preMiddleware: (url, params) => Promise.resolve([url, params]),
};
function jsToUrlEncoded(element, key = '', list = []) {
const components = list;
if (typeof element === 'object') {
for (let idx in element) {
jsToUrlEncoded(element[idx], key ? `${key}[${idx}]` : idx, components);
}
} else {
components.push(`${encodeURIComponent(key)}=${encodeURIComponent(element)}`);
}
return components.join('&');
}
const self_get = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/self/get`;
const querySchema = {
type: 'object',
required: ['token'],
properties: { token: { type: 'string' } },
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'self_get',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching self_get',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
userId: { type: 'string', description: 'Unique id', example: '747432131' },
nick: { type: 'string', description: 'Unique nick', example: 'test_api_bot' },
firstName: { type: 'string', description: 'Name', example: 'TestBot' },
about: {
type: 'string',
description: 'The description of the bot',
example: 'The description of the bot',
},
photo: { type: 'array', items: { $ref: '#url' } },
ok: { type: 'boolean', description: 'Request status' },
},
required: ['userId', 'nick'],
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_sendText = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/sendText`;
const querySchema = {
type: 'object',
required: ['token', 'chatId', 'text'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
text: { type: 'string' },
replyMsgId: { type: 'array', items: { type: 'integer' } },
forwardChatId: { type: 'string' },
forwardMsgId: { type: 'array', items: { type: 'integer' } },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_sendText',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_sendText',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
msgId: { type: 'string', example: '57883346846815032' },
ok: { type: 'boolean', description: 'Статус запроса' },
},
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_sendFile = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/sendFile`;
const querySchema = {
type: 'object',
required: ['token', 'chatId', 'fileId'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
fileId: { type: 'string' },
caption: { type: 'string' },
replyMsgId: { type: 'array', items: { type: 'integer' } },
forwardChatId: { type: 'string' },
forwardMsgId: { type: 'array', items: { type: 'integer' } },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_sendFile',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_sendFile',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
msgId: { type: 'string', example: '57883346846815032' },
ok: { type: 'boolean', description: 'Статус запроса' },
},
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_uploadAndSendFile = async (
{ query = {}, data = {} } = {},
currentConfig = defaultConfig
) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/sendFile`;
const querySchema = {
type: 'object',
required: ['token', 'chatId'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
caption: { type: 'string' },
replyMsgId: { type: 'array', items: { type: 'integer' } },
forwardChatId: { type: 'string' },
forwardMsgId: { type: 'array', items: { type: 'integer' } },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_uploadAndSendFile',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'multipart/form-data',
};
const bodySchema = { type: 'object', properties: { file: { type: 'object', format: 'binary' } } };
const isBodyValid = ajv.validate(bodySchema, data);
if (!isBodyValid) {
throw new RequestValidationError({
message: 'Request body schema validation error',
method: 'messages_uploadAndSendFile',
element: 'body',
errors: ajv.errors || [],
});
}
let requestParams;
let body = null;
if (data && typeof data === 'object') {
body = Object(object_to_formdata__WEBPACK_IMPORTED_MODULE_2__["serialize"])(data);
}
if (body) {
requestParams = {
method: 'POST',
headers: requestHeaders,
body,
};
} else {
requestParams = {
method: 'POST',
headers: requestHeaders,
};
}
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_uploadAndSendFile',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
fileId: { type: 'string', example: '0dC76vcKS3XZOtG5DVs9y15d1daefa1ae' },
msgId: { type: 'string', example: '57883346846815032' },
ok: { type: 'boolean', description: 'Статус запроса' },
},
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_sendVoice = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/sendVoice`;
const querySchema = {
type: 'object',
required: ['token', 'chatId', 'fileId'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
fileId: { type: 'string' },
replyMsgId: { type: 'array', items: { type: 'integer' } },
forwardChatId: { type: 'string' },
forwardMsgId: { type: 'array', items: { type: 'integer' } },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_sendVoice',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_sendVoice',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
msgId: { type: 'string', example: '57883346846815032' },
ok: { type: 'boolean', description: 'Статус запроса' },
},
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_uploadAndSendVoice = async (
{ query = {}, data = {} } = {},
currentConfig = defaultConfig
) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/sendVoice`;
const querySchema = {
type: 'object',
required: ['token', 'chatId'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
replyMsgId: { type: 'array', items: { type: 'integer' } },
forwardChatId: { type: 'string' },
forwardMsgId: { type: 'array', items: { type: 'integer' } },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_uploadAndSendVoice',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'multipart/form-data',
};
const bodySchema = { type: 'object', properties: { file: { type: 'object', format: 'binary' } } };
const isBodyValid = ajv.validate(bodySchema, data);
if (!isBodyValid) {
throw new RequestValidationError({
message: 'Request body schema validation error',
method: 'messages_uploadAndSendVoice',
element: 'body',
errors: ajv.errors || [],
});
}
let requestParams;
let body = null;
if (data && typeof data === 'object') {
body = Object(object_to_formdata__WEBPACK_IMPORTED_MODULE_2__["serialize"])(data);
}
if (body) {
requestParams = {
method: 'POST',
headers: requestHeaders,
body,
};
} else {
requestParams = {
method: 'POST',
headers: requestHeaders,
};
}
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_uploadAndSendVoice',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
fileId: { type: 'string', example: '0dC76vcKS3XZOtG5DVs9y15d1daefa1ae' },
msgId: { type: 'string', example: '57883346846815032' },
ok: { type: 'boolean', description: 'Статус запроса' },
},
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_editText = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/editText`;
const querySchema = {
type: 'object',
required: ['token', 'chatId', 'msgId', 'text'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
msgId: { type: 'integer' },
text: { type: 'string' },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_editText',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_editText',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: { ok: { type: 'boolean', description: 'Статус запроса' } },
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_deleteMessages = async (
{ query = {} } = {},
currentConfig = defaultConfig
) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/deleteMessages`;
const querySchema = {
type: 'object',
required: ['token', 'chatId', 'msgId'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
msgId: { type: 'array', items: { type: 'integer' } },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_deleteMessages',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_deleteMessages',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: { ok: { type: 'boolean', description: 'Статус запроса' } },
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const messages_answerCallbackQuery = async (
{ query = {} } = {},
currentConfig = defaultConfig
) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/messages/answerCallbackQuery`;
const querySchema = {
type: 'object',
required: ['queryId'],
properties: {
queryId: { type: 'string' },
text: { type: 'string' },
showAlert: { type: 'boolean' },
url: { type: 'string' },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'messages_answerCallbackQuery',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching messages_answerCallbackQuery',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: { ok: { type: 'boolean', description: 'Статус запроса' } },
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const chats_sendActions = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/chats/sendActions`;
const querySchema = {
type: 'object',
required: ['token', 'chatId', 'actions'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
actions: { type: 'array', items: { type: 'string', enum: ['looking', 'typing'] } },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'chats_sendActions',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching chats_sendActions',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: { ok: { type: 'boolean', description: 'Статус запроса' } },
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const chats_getInfo = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/chats/getInfo`;
const querySchema = {
type: 'object',
required: ['token', 'chatId'],
properties: { token: { type: 'string' }, chatId: { type: 'string' } },
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'chats_getInfo',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching chats_getInfo',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
oneOf: [{ $ref: '#chatPrivate' }, { $ref: '#chatGroup' }, { $ref: '#chatChannel' }],
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const chats_getAdmins = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/chats/getAdmins`;
const querySchema = {
type: 'object',
required: ['token', 'chatId'],
properties: { token: { type: 'string' }, chatId: { type: 'string' } },
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'chats_getAdmins',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching chats_getAdmins',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
admins: {
type: 'array',
items: { oneOf: [{ $ref: '#userCreator' }, { $ref: '#user' }] },
},
},
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const chats_getMembers = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/chats/getMembers`;
const querySchema = {
type: 'object',
required: ['token', 'chatId'],
properties: {
token: { type: 'string' },
chatId: { type: 'string' },
cursor: { type: 'string' },
},
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'chats_getMembers',
element: 'query',
errors: ajv.errors || [],
});
}
if (Object.keys(query)) {
requestUrl = `${requestUrl}?${Object(query_string__WEBPACK_IMPORTED_MODULE_1__["stringify"])(query, { arrayFormat: 'bracket' })}`;
}
const requestHeaders = {
'Content-Type': 'application/json',
};
const requestParams = {
method: 'GET',
headers: requestHeaders,
};
const [processedUrl, processedParams] = await config.preMiddleware(requestUrl, requestParams);
const responseObject = await fetch(processedUrl, processedParams);
const responseContentType = responseObject.headers.get('Content-Type');
let responseJson = null;
const responseText = await responseObject.text();
if (
responseContentType.startsWith('application/json') ||
responseContentType.startsWith('application/hal+json')
) {
responseJson = JSON.parse(responseText);
}
if (!responseObject.ok) {
throw new ApiError({
message: 'Api error while fetching chats_getMembers',
status: responseObject.status,
statusText: responseObject.statusText,
response: responseJson,
headers: responseObject.headers,
});
}
const responseSchema = {
'200': {
response: {
type: 'object',
properties: {
members: {
type: 'array',
items: { oneOf: [{ $ref: '#userCreator' }, { $ref: '#userAdmin' }, { $ref: '#user' }] },
},
},
},
contentTypes: ['application/json;charset=utf-8'],
},
};
const responseStatus = responseObject.status;
const acceptedContentTypes =
responseSchema[responseStatus] && responseSchema[responseStatus].contentTypes;
if (
acceptedContentTypes &&
!acceptedContentTypes.includes(responseContentType) &&
(!responseContentType.startsWith('application/json') ||
!acceptedContentTypes.find((acceptedContentType) =>
acceptedContentType.startsWith('application/json')
))
) {
throw new Error('Incorrect content type');
}
return {
json: responseJson,
text: responseText,
headers: responseObject.headers,
};
};
const chats_getBlockedUsers = async ({ query = {} } = {}, currentConfig = defaultConfig) => {
const config = { ...defaultConfig, ...currentConfig };
let requestUrl = `${config.baseUrl}/chats/getBlockedUsers`;
const querySchema = {
type: 'object',
required: ['token', 'chatId'],
properties: { token: { type: 'string' }, chatId: { type: 'string' } },
additionalProperties: false,
};
function isQuery(obj) {
const isValid = ajv.validate(querySchema, obj);
return !!isValid;
}
if (!isQuery(query)) {
throw new RequestValidationError({
message: 'Request query string schema validation error',
method: 'chats_getBlockedUsers',
ele